Init

internal/controllers/api/auth_controller.go

@@ -0,0 +1,120 @@
+package api
+
+import (
+	"cs-agent/internal/pkg/config"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/services"
+	"net/url"
+	"strings"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type AuthController struct {
+	Ctx iris.Context
+}
+
+func (c *AuthController) PostLogin() *web.JsonResult {
+	cfg := config.Current()
+	req := request.LoginRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+
+	ret, err := services.AuthService.Login(req, cfg.Auth, c.Ctx.RemoteAddr(), c.Ctx.GetHeader("User-Agent"))
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(ret)
+}
+
+func (c *AuthController) PostRefresh_token() *web.JsonResult {
+	cfg := config.Current()
+	req := request.RefreshTokenRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+
+	ret, err := services.AuthService.RefreshToken(req.RefreshToken, cfg.Auth, c.Ctx.RemoteAddr(), c.Ctx.GetHeader("User-Agent"))
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(ret)
+}
+
+func (c *AuthController) GetWxwork_login() {
+	loginURL, err := services.WxWorkLoginService.BuildWxWorkLoginURL(c.Ctx.URLParam("next"))
+	if err != nil {
+		c.redirectWxWorkError(err.Error())
+		return
+	}
+	c.Ctx.Redirect(loginURL, iris.StatusFound)
+}
+
+func (c *AuthController) GetWxwork_qr_login() {
+	loginURL, err := services.WxWorkLoginService.BuildWxWorkQRCodeLoginURL(c.Ctx.URLParam("next"))
+	if err != nil {
+		c.redirectWxWorkError(err.Error())
+		return
+	}
+	c.Ctx.Redirect(loginURL, iris.StatusFound)
+}
+
+func (c *AuthController) GetWxwork_callback() {
+	cfg := config.Current()
+	ticket, next, err := services.WxWorkLoginService.LoginByWxWork(
+		c.Ctx.URLParam("code"),
+		c.Ctx.URLParam("state"),
+		cfg.Auth,
+		c.Ctx.RemoteAddr(),
+		c.Ctx.GetHeader("User-Agent"),
+	)
+	if err != nil {
+		c.redirectWxWorkError(err.Error())
+		return
+	}
+	c.Ctx.Redirect("/login/wxwork/callback?ticket="+url.QueryEscape(ticket)+"&next="+url.QueryEscape(next), iris.StatusFound)
+}
+
+func (c *AuthController) PostWxwork_exchange() *web.JsonResult {
+	req := request.WxWorkExchangeRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	ret, err := services.WxWorkLoginService.ExchangeWxWorkLoginTicket(req.Ticket)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(ret)
+}
+
+func (c *AuthController) PostLogout() *web.JsonResult {
+	req := request.LogoutRequest{}
+	if c.Ctx.GetContentLength() > 0 {
+		if err := params.ReadJSON(c.Ctx, &req); err != nil {
+			return web.JsonError(err)
+		}
+	}
+
+	if err := services.AuthService.Logout(c.Ctx.GetHeader("Authorization"), req.RefreshToken); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *AuthController) GetProfile() *web.JsonResult {
+	ret, err := services.AuthService.CurrentProfile(c.Ctx)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(ret)
+}
+
+func (c *AuthController) redirectWxWorkError(message string) {
+	if idx := strings.Index(message, ": "); idx >= 0 {
+		message = message[idx+2:]
+	}
+	c.Ctx.Redirect("/login?wxworkError="+url.QueryEscape(message), iris.StatusFound)
+}

internal/controllers/console/agent_controller.go

@@ -0,0 +1,101 @@
+package console
+
+import (
+	"cs-agent/internal/builders"
+	"cs-agent/internal/pkg/constants"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type AgentController struct {
+	Ctx iris.Context
+}
+
+func (c *AgentController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAgentView); err != nil {
+		return web.JsonError(err)
+	}
+	list, paging := services.AgentProfileService.FindPageByCnd(params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "userId"},
+		params.QueryFilter{ParamName: "teamId"},
+		params.QueryFilter{ParamName: "serviceStatus"},
+		params.QueryFilter{ParamName: "agentCode", Op: params.Like},
+		params.QueryFilter{ParamName: "displayName", Op: params.Like},
+	).Desc("id"))
+	results := builders.BuildAgentProfileList(list)
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *AgentController) GetList_all() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAgentView); err != nil {
+		return web.JsonError(err)
+	}
+	list := services.AgentProfileService.Find(params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "userId"},
+		params.QueryFilter{ParamName: "teamId"},
+		params.QueryFilter{ParamName: "serviceStatus"},
+		params.QueryFilter{ParamName: "agentCode", Op: params.Like},
+	).Desc("id"))
+
+	return web.JsonData(builders.BuildAgentProfileList(list))
+}
+
+func (c *AgentController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAgentView); err != nil {
+		return web.JsonError(err)
+	}
+	item := services.AgentProfileService.Get(id)
+	if item == nil {
+		return web.JsonErrorMsg("客服档案不存在")
+	}
+	return web.JsonData(builders.BuildAgentProfileResponse(item))
+}
+
+func (c *AgentController) PostCreate() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAgentCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.CreateAgentProfileRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.AgentProfileService.CreateAgentProfile(req, user)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildAgentProfileResponse(item))
+}
+
+func (c *AgentController) PostUpdate() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAgentUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.UpdateAgentProfileRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.AgentProfileService.UpdateAgentProfile(req, user); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *AgentController) PostDelete() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAgentDelete); err != nil {
+		return web.JsonError(err)
+	}
+	req := request.DeleteAgentProfileRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.AgentProfileService.DeleteAgentProfile(req.ID); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}

internal/controllers/console/agent_run_log_controller.go

@@ -0,0 +1,52 @@
+package console
+
+import (
+	"cs-agent/internal/builders"
+	"cs-agent/internal/pkg/constants"
+	"cs-agent/internal/pkg/dto/response"
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type AgentRunLogController struct {
+	Ctx iris.Context
+}
+
+func (c *AgentRunLogController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionConversationView); err != nil {
+		return web.JsonError(err)
+	}
+
+	cnd := params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "conversationId"},
+		params.QueryFilter{ParamName: "messageId"},
+		params.QueryFilter{ParamName: "aiAgentId"},
+		params.QueryFilter{ParamName: "plannedAction"},
+		params.QueryFilter{ParamName: "plannedSkillCode", Op: params.Like},
+		params.QueryFilter{ParamName: "finalAction"},
+		params.QueryFilter{ParamName: "userMessage", Op: params.Like},
+	).Desc("id")
+	queryParams := params.NewQueryParams(c.Ctx)
+	queryParams.Cnd = *cnd
+	list, paging := services.AgentRunLogService.FindPageByParams(queryParams)
+	results := make([]response.AgentRunLogResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, builders.BuildAgentRunLog(&item))
+	}
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *AgentRunLogController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionConversationView); err != nil {
+		return web.JsonError(err)
+	}
+
+	item := services.AgentRunLogService.Get(id)
+	if item == nil {
+		return web.JsonErrorMsg("Agent 运行日志不存在")
+	}
+	return web.JsonData(builders.BuildAgentRunLog(item))
+}

internal/controllers/console/agent_team_controller.go

@@ -0,0 +1,124 @@
+package console
+
+import (
+	"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/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/sqls"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type AgentTeamController struct {
+	Ctx iris.Context
+}
+
+func (c *AgentTeamController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAgentTeamView); err != nil {
+		return web.JsonError(err)
+	}
+	cnd := params.NewSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "status"},
+		params.QueryFilter{ParamName: "leaderUserId"},
+		params.QueryFilter{ParamName: "name", Op: params.Like},
+	).Desc("id")
+	if _, ok := params.Get(c.Ctx, "status"); !ok {
+		cnd.Where("status <> ?", enums.StatusDeleted)
+	}
+	list := services.AgentTeamService.Find(cnd)
+	results := make([]response.AgentTeamResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, buildAgentTeamResponse(&item))
+	}
+	return web.JsonData(results)
+}
+
+func (c *AgentTeamController) GetList_all() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAgentTeamView); err != nil {
+		return web.JsonError(err)
+	}
+	list := services.AgentTeamService.Find(sqls.NewCnd().Eq("status", enums.StatusOk))
+	results := make([]response.AgentTeamResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, buildAgentTeamResponse(&item))
+	}
+	return web.JsonData(results)
+}
+
+func (c *AgentTeamController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAgentTeamView); err != nil {
+		return web.JsonError(err)
+	}
+	item := services.AgentTeamService.Get(id)
+	if item == nil || item.Status == enums.StatusDeleted {
+		return web.JsonErrorMsg("客服组不存在")
+	}
+	return web.JsonData(buildAgentTeamResponse(item))
+}
+
+func (c *AgentTeamController) PostCreate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAgentTeamCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.CreateAgentTeamRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.AgentTeamService.CreateAgentTeam(req, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(buildAgentTeamResponse(item))
+}
+
+func (c *AgentTeamController) PostUpdate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAgentTeamUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.UpdateAgentTeamRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.AgentTeamService.UpdateAgentTeam(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *AgentTeamController) PostDelete() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAgentTeamDelete)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.DeleteAgentTeamRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.AgentTeamService.DeleteAgentTeam(req.ID, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func buildAgentTeamResponse(item *models.AgentTeam) response.AgentTeamResponse {
+	ret := response.AgentTeamResponse{
+		ID:           item.ID,
+		Name:         item.Name,
+		LeaderUserID: item.LeaderUserID,
+		Status:       item.Status,
+		Description:  item.Description,
+		Remark:       item.Remark,
+	}
+	if user := services.UserService.Get(item.LeaderUserID); user != nil {
+		ret.LeaderUsername = user.Username
+		ret.LeaderNickname = user.Nickname
+	}
+	return ret
+}

internal/controllers/console/agent_team_schedule_controller.go

@@ -0,0 +1,103 @@
+package console
+
+import (
+	"cs-agent/internal/models"
+	"cs-agent/internal/pkg/constants"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/pkg/dto/response"
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type AgentTeamScheduleController struct {
+	Ctx iris.Context
+}
+
+func (c *AgentTeamScheduleController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAgentTeamScheduleView); err != nil {
+		return web.JsonError(err)
+	}
+	cnd := params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "teamId"},
+	).Desc("start_at").Desc("id")
+	list, paging := services.AgentTeamScheduleService.FindPageByCnd(cnd)
+	results := make([]response.AgentTeamScheduleResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, buildAgentTeamScheduleResponse(&item))
+	}
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *AgentTeamScheduleController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAgentTeamScheduleView); err != nil {
+		return web.JsonError(err)
+	}
+	item := services.AgentTeamScheduleService.Get(id)
+	if item == nil {
+		return web.JsonErrorMsg("客服组排班不存在")
+	}
+	return web.JsonData(buildAgentTeamScheduleResponse(item))
+}
+
+func (c *AgentTeamScheduleController) PostCreate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAgentTeamScheduleCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.CreateAgentTeamScheduleRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.AgentTeamScheduleService.CreateAgentTeamSchedule(req, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(buildAgentTeamScheduleResponse(item))
+}
+
+func (c *AgentTeamScheduleController) PostUpdate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAgentTeamScheduleUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.UpdateAgentTeamScheduleRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.AgentTeamScheduleService.UpdateAgentTeamSchedule(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *AgentTeamScheduleController) PostDelete() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAgentTeamScheduleDelete); err != nil {
+		return web.JsonError(err)
+	}
+	req := request.DeleteAgentTeamScheduleRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.AgentTeamScheduleService.DeleteAgentTeamSchedule(req.ID); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func buildAgentTeamScheduleResponse(item *models.AgentTeamSchedule) response.AgentTeamScheduleResponse {
+	ret := response.AgentTeamScheduleResponse{
+		ID:         item.ID,
+		TeamID:     item.TeamID,
+		StartAt:    item.StartAt.Format("2006-01-02 15:04:05"),
+		EndAt:      item.EndAt.Format("2006-01-02 15:04:05"),
+		SourceType: item.SourceType,
+		Remark:     item.Remark,
+	}
+	if team := services.AgentTeamService.Get(item.TeamID); team != nil {
+		ret.TeamName = team.Name
+	}
+	return ret
+}

internal/controllers/console/ai_agent_controller.go

@@ -0,0 +1,183 @@
+package console
+
+import (
+	"encoding/json"
+	"strings"
+
+	"cs-agent/internal/models"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/pkg/dto/response"
+	"cs-agent/internal/pkg/enums"
+	"cs-agent/internal/pkg/utils"
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/sqls"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type AIAgentController struct {
+	Ctx iris.Context
+}
+
+func (c *AIAgentController) AnyList() *web.JsonResult {
+	cnd := params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "status"},
+		params.QueryFilter{ParamName: "name", Op: params.Like},
+		params.QueryFilter{ParamName: "code", Op: params.Like},
+	).Desc("sort_no").Desc("id")
+	list, paging := services.AIAgentService.FindPageByCnd(cnd)
+	results := make([]response.AIAgentResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, buildAIAgentResponse(&item))
+	}
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *AIAgentController) GetList_all() *web.JsonResult {
+	list := services.AIAgentService.Find(sqls.NewCnd().Where("status = ?", enums.StatusOk).Desc("sort_no").Desc("id"))
+	results := make([]response.AIAgentResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, buildAIAgentResponse(&item))
+	}
+	return web.JsonData(results)
+}
+
+func (c *AIAgentController) GetBy(id int64) *web.JsonResult {
+	item := services.AIAgentService.Get(id)
+	if item == nil {
+		return web.JsonErrorMsg("AI Agent 不存在")
+	}
+	return web.JsonData(buildAIAgentResponse(item))
+}
+
+func (c *AIAgentController) PostCreate() *web.JsonResult {
+	req := request.CreateAIAgentRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.AIAgentService.CreateAIAgent(req, services.AuthService.GetAuthPrincipal(c.Ctx))
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(buildAIAgentResponse(item))
+}
+
+func (c *AIAgentController) PostUpdate() *web.JsonResult {
+	req := request.UpdateAIAgentRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.AIAgentService.UpdateAIAgent(req, services.AuthService.GetAuthPrincipal(c.Ctx)); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *AIAgentController) PostDelete() *web.JsonResult {
+	req := request.DeleteAIAgentRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.AIAgentService.DeleteAIAgent(req.ID, services.AuthService.GetAuthPrincipal(c.Ctx)); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *AIAgentController) PostUpdate_sort() *web.JsonResult {
+	var ids []int64
+	if err := c.Ctx.ReadJSON(&ids); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.AIAgentService.UpdateSort(ids); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *AIAgentController) PostUpdate_status() *web.JsonResult {
+	req := request.UpdateAIAgentStatusRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.AIAgentService.UpdateStatus(req.ID, req.Status, services.AuthService.GetAuthPrincipal(c.Ctx)); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func buildAIAgentResponse(item *models.AIAgent) response.AIAgentResponse {
+	ret := response.AIAgentResponse{
+		ID:                  item.ID,
+		Name:                item.Name,
+		Description:         item.Description,
+		Status:              item.Status,
+		StatusName:          enums.GetStatusLabel(item.Status),
+		AIConfigID:          item.AIConfigID,
+		ServiceMode:         item.ServiceMode,
+		ServiceModeName:     enums.GetIMConversationServiceModeLabel(enums.IMConversationServiceMode(item.ServiceMode)),
+		SystemPrompt:        item.SystemPrompt,
+		WelcomeMessage:      item.WelcomeMessage,
+		ReplyTimeoutSeconds: item.ReplyTimeoutSeconds,
+		HandoffMode:         item.HandoffMode,
+		HandoffModeName:     enums.GetAIAgentHandoffModeLabel(enums.AIAgentHandoffMode(item.HandoffMode)),
+		MaxAIReplyRounds:    item.MaxAIReplyRounds,
+		FallbackMode:        item.FallbackMode,
+		FallbackModeName:    enums.GetAIAgentFallbackModeLabel(enums.AIAgentFallbackMode(item.FallbackMode)),
+		FallbackMessage:     item.FallbackMessage,
+		KnowledgeIDs:        utils.SplitInt64s(item.KnowledgeIDs),
+		SkillIDs:            utils.SplitInt64s(item.SkillIDs),
+		KnowledgeBaseNames:  make([]string, 0),
+		Skills:              make([]response.AIAgentSkillResponse, 0),
+		Teams:               make([]response.AIAgentTeamResponse, 0),
+		DirectTools:         make([]response.AIAgentMCPToolResponse, 0),
+		SortNo:              item.SortNo,
+		Remark:              item.Remark,
+		CreatedAt:           item.CreatedAt.Format("2006-01-02 15:04:05"),
+		UpdatedAt:           item.UpdatedAt.Format("2006-01-02 15:04:05"),
+		CreateUserName:      item.CreateUserName,
+		UpdateUserName:      item.UpdateUserName,
+	}
+	if aiConfig := services.AIConfigService.Get(item.AIConfigID); aiConfig != nil {
+		ret.AIConfigName = aiConfig.Name
+	}
+	for _, id := range utils.SplitInt64s(item.TeamIDs) {
+		if team := services.AgentTeamService.Get(id); team != nil {
+			ret.Teams = append(ret.Teams, response.AIAgentTeamResponse{
+				ID:   team.ID,
+				Name: team.Name,
+			})
+		}
+	}
+	for _, id := range ret.KnowledgeIDs {
+		if knowledgeBase := services.KnowledgeBaseService.Get(id); knowledgeBase != nil {
+			ret.KnowledgeBaseNames = append(ret.KnowledgeBaseNames, knowledgeBase.Name)
+		}
+	}
+	for _, id := range ret.SkillIDs {
+		if skill := services.SkillDefinitionService.Get(id); skill != nil {
+			ret.Skills = append(ret.Skills, response.AIAgentSkillResponse{
+				ID:   skill.ID,
+				Code: skill.Code,
+				Name: skill.Name,
+			})
+		}
+	}
+	if raw := strings.TrimSpace(item.AllowedMCPTools); raw != "" {
+		var directTools []request.AIAgentMCPToolRequest
+		if err := json.Unmarshal([]byte(raw), &directTools); err == nil {
+			for _, tool := range directTools {
+				ret.DirectTools = append(ret.DirectTools, response.AIAgentMCPToolResponse{
+					ServerCode:  strings.TrimSpace(tool.ServerCode),
+					ToolName:    strings.TrimSpace(tool.ToolName),
+					Title:       strings.TrimSpace(tool.Title),
+					Description: strings.TrimSpace(tool.Description),
+					Arguments:   tool.Arguments,
+				})
+			}
+		}
+	}
+	return ret
+}

internal/controllers/console/ai_config_controller.go

@@ -0,0 +1,143 @@
+package console
+
+import (
+	"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/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type AIConfigController struct {
+	Ctx iris.Context
+}
+
+func (c *AIConfigController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAIConfigView); err != nil {
+		return web.JsonError(err)
+	}
+	list, paging := services.AIConfigService.FindPageByCnd(params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "status"},
+		params.QueryFilter{ParamName: "provider"},
+		params.QueryFilter{ParamName: "modelType"},
+		params.QueryFilter{ParamName: "name", Op: params.Like},
+		params.QueryFilter{ParamName: "modelName", Op: params.Like},
+	).Desc("sort_no").Desc("id"))
+	results := make([]response.AIConfigResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, response.BuildAIConfigResponse(&item))
+	}
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *AIConfigController) AnyList_all() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAIConfigView); err != nil {
+		return web.JsonError(err)
+	}
+
+	list := services.AIConfigService.Find(params.NewSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "modelType"},
+	).Eq("status", enums.StatusOk).Desc("sort_no").Desc("id"))
+
+	results := make([]response.AIConfigResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, response.BuildAIConfigResponse(&item))
+	}
+	return web.JsonData(results)
+}
+
+func (c *AIConfigController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAIConfigView); err != nil {
+		return web.JsonError(err)
+	}
+
+	item := services.AIConfigService.Get(id)
+	if item == nil || item.Status == enums.StatusDeleted {
+		return web.JsonErrorMsg("AI配置不存在")
+	}
+	return web.JsonData(response.BuildAIConfigResponse(item))
+}
+
+func (c *AIConfigController) PostCreate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAIConfigCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.CreateAIConfigRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.AIConfigService.CreateAIConfig(req, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(response.BuildAIConfigResponse(item))
+}
+
+func (c *AIConfigController) PostUpdate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAIConfigUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.UpdateAIConfigRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.AIConfigService.UpdateAIConfig(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *AIConfigController) PostDelete() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAIConfigDelete)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.DeleteAIConfigRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.AIConfigService.DeleteAIConfig(req.ID, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *AIConfigController) PostUpdate_status() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAIConfigUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.UpdateAIConfigStatusRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.AIConfigService.UpdateStatus(req.ID, req.Status, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *AIConfigController) PostUpdate_sort() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAIConfigUpdate); err != nil {
+		return web.JsonError(err)
+	}
+
+	var ids []int64
+	if err := c.Ctx.ReadJSON(&ids); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.AIConfigService.UpdateSort(ids); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}

internal/controllers/console/asset_controller.go

@@ -0,0 +1,92 @@
+package console
+
+import (
+	"cs-agent/internal/builders"
+	"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/services"
+	"strings"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type AssetController struct {
+	Ctx iris.Context
+}
+
+func (c *AssetController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAssetView); err != nil {
+		return web.JsonError(err)
+	}
+
+	cnd := params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "provider"},
+		params.QueryFilter{ParamName: "status"},
+		params.QueryFilter{ParamName: "createUserId"},
+		params.QueryFilter{ParamName: "filename", Op: params.Like},
+	).Desc("id")
+	if strings.TrimSpace(c.Ctx.URLParam("status")) == "" {
+		cnd = cnd.Eq("status", enums.AssetStatusSuccess)
+	}
+
+	list, paging := services.AssetService.FindPageByCnd(cnd)
+	results := make([]response.AssetResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, builders.BuildAsset(&item))
+	}
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *AssetController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAssetView); err != nil {
+		return web.JsonError(err)
+	}
+	item := services.AssetService.Get(id)
+	if item == nil {
+		return web.JsonErrorMsg("文件不存在")
+	}
+	return web.JsonData(builders.BuildAsset(item))
+}
+
+func (c *AssetController) PostCreate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAssetCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.CreateAssetRequest{}
+	if err := params.ReadForm(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	f, header, err := c.Ctx.FormFile("file")
+	if err != nil {
+		return web.JsonErrorMsg("请选择上传文件")
+	}
+	_ = f.Close()
+
+	item, err := services.AssetService.UploadFile(header, req.Prefix, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildAsset(item))
+}
+
+func (c *AssetController) PostDelete() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionAssetDelete)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.DeleteAssetRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.AssetService.DeleteAsset(req.ID, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}

internal/controllers/console/channel_controller.go

@@ -0,0 +1,118 @@
+package console
+
+import (
+	"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/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type ChannelController struct {
+	Ctx iris.Context
+}
+
+func (c *ChannelController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionChannelView); err != nil {
+		return web.JsonError(err)
+	}
+	list, paging := services.ChannelService.FindPageByCnd(params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "status"},
+		params.QueryFilter{ParamName: "name", Op: params.Like},
+		params.QueryFilter{ParamName: "channelType"},
+		params.QueryFilter{ParamName: "channelId", Op: params.Like},
+	).Where("status <> ?", enums.StatusDeleted).Desc("id"))
+	results := make([]response.ChannelResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, buildChannelResponse(&item))
+	}
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *ChannelController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionChannelView); err != nil {
+		return web.JsonError(err)
+	}
+	item := services.ChannelService.Get(id)
+	if item == nil || item.Status == enums.StatusDeleted {
+		return web.JsonErrorMsg("channel not found")
+	}
+	return web.JsonData(buildChannelResponse(item))
+}
+
+func (c *ChannelController) PostCreate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionChannelCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.CreateChannelRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.ChannelService.CreateChannel(req, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(buildChannelResponse(item))
+}
+
+func (c *ChannelController) PostUpdate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionChannelUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.UpdateChannelRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.ChannelService.UpdateChannel(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *ChannelController) PostUpdate_status() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionChannelUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.UpdateChannelStatusRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.ChannelService.UpdateStatus(req.ID, req.Status, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *ChannelController) PostDelete() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionChannelDelete)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.DeleteChannelRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.ChannelService.DeleteChannel(req.ID, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func buildChannelResponse(item *models.Channel) response.ChannelResponse {
+	ret := response.BuildChannelResponse(item)
+	if item == nil {
+		return ret
+	}
+	if aiAgent := services.AIAgentService.Get(item.AIAgentID); aiAgent != nil {
+		ret.AIAgentName = aiAgent.Name
+	}
+	return ret
+}

internal/controllers/console/company_controller.go

@@ -0,0 +1,113 @@
+package console
+
+import (
+	"cs-agent/internal/builders"
+	"cs-agent/internal/pkg/constants"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/pkg/enums"
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type CompanyController struct {
+	Ctx iris.Context
+}
+
+func (c *CompanyController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionCompanyView); err != nil {
+		return web.JsonError(err)
+	}
+	list, paging := services.CompanyService.FindPageByCnd(params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "status"},
+		params.QueryFilter{ParamName: "name", Op: params.Like},
+		params.QueryFilter{ParamName: "code", Op: params.Like},
+	).Where("status <> ?", enums.StatusDeleted).Desc("id"))
+
+	results := builders.BuildCompanyList(list)
+	companyIDs := make([]int64, 0, len(results))
+	for _, item := range results {
+		companyIDs = append(companyIDs, item.ID)
+	}
+	countMap := services.CustomerService.CountByCompanyIDs(companyIDs)
+	for i := range results {
+		results[i].CustomerCount = countMap[results[i].ID]
+	}
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *CompanyController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionCompanyView); err != nil {
+		return web.JsonError(err)
+	}
+	item := services.CompanyService.Get(id)
+	if item == nil || item.Status == enums.StatusDeleted {
+		return web.JsonData(nil)
+	}
+	ret := builders.BuildCompany(item)
+	return web.JsonData(&ret)
+}
+
+func (c *CompanyController) PostCreate() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionCompanyCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.CreateCompanyRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.CompanyService.CreateCompany(req, user)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	ret := builders.BuildCompany(item)
+	return web.JsonData(&ret)
+}
+
+func (c *CompanyController) PostUpdate() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionCompanyUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.UpdateCompanyRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.CompanyService.UpdateCompany(req, user); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *CompanyController) PostDelete() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionCompanyDelete)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.DeleteCompanyRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.CompanyService.DeleteCompany(req.ID, *user); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *CompanyController) PostUpdate_status() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionCompanyUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.UpdateCompanyStatusRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.CompanyService.UpdateStatus(req.ID, req.Status, user); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}

internal/controllers/console/conversation_controller.go

@@ -0,0 +1,365 @@
+package console
+
+import (
+	"cs-agent/internal/builders"
+	"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/services"
+	"strconv"
+	"strings"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/common/strs"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+	"github.com/spf13/cast"
+)
+
+type ConversationController struct {
+	Ctx iris.Context
+}
+
+func (c *ConversationController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionConversationView); err != nil {
+		return web.JsonError(err)
+	}
+
+	cnd := params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "status"},
+		params.QueryFilter{ParamName: "externalSource"},
+		params.QueryFilter{ParamName: "serviceMode"},
+		params.QueryFilter{ParamName: "currentAssigneeId"},
+	).Desc("last_message_at").Desc("id")
+
+	paging := params.GetPaging(c.Ctx)
+
+	if keyword, _ := params.Get(c.Ctx, "keyword"); strs.IsNotBlank(keyword) {
+		keywordLike := "%" + strings.TrimSpace(keyword) + "%"
+		cnd.Where("subject LIKE ? OR external_id LIKE ? OR last_message_summary LIKE ?", keywordLike, keywordLike, keywordLike)
+	}
+
+	// 标签搜索
+	if tagID, _ := params.GetInt64(c.Ctx, "tagId"); tagID > 0 {
+		tagIDs := services.TagService.GetSelfAndDescendantIDs(tagID)
+		if len(tagIDs) == 0 {
+			return web.JsonData(&web.PageResult{
+				Results: []response.ConversationResponse{},
+				Page:    paging,
+			})
+		}
+		cnd.Where("id IN (SELECT conversation_id FROM conversation_tag_rels WHERE tag_id IN (?))", tagIDs)
+	}
+	if agentTeamID, _ := params.GetInt64(c.Ctx, "agentTeamId"); agentTeamID > 0 {
+		userIDs := services.AgentProfileService.GetUserIDsByTeamID(agentTeamID)
+		if len(userIDs) == 0 {
+			return web.JsonData(&web.PageResult{
+				Results: []response.ConversationResponse{},
+				Page:    paging,
+			})
+		}
+		cnd.In("current_assignee_id", userIDs)
+	}
+
+	list, paging := services.ConversationService.FindPageByCnd(cnd)
+	results := make([]response.ConversationResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, builders.BuildConversation(&item))
+	}
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *ConversationController) AnyConversations() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionConversationView)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	filterValue, _ := params.Get(c.Ctx, "filter")
+	keyword, _ := params.Get(c.Ctx, "keyword")
+	paging := params.GetPaging(c.Ctx)
+
+	list, paging, err := services.ConversationService.ListConversations(
+		operator.UserID,
+		request.AgentConversationFilter(strings.TrimSpace(filterValue)),
+		keyword,
+		paging,
+	)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	results := make([]response.ConversationResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, builders.BuildConversation(&item))
+	}
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *ConversationController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionConversationView); err != nil {
+		return web.JsonError(err)
+	}
+
+	item := services.ConversationService.Get(id)
+	if item == nil {
+		return web.JsonErrorMsg("会话不存在")
+	}
+
+	detail := response.ConversationDetailResponse{
+		ConversationResponse: builders.BuildConversation(item),
+		Participants:         builders.BuildParticipantResponses(id),
+	}
+	return web.JsonData(detail)
+}
+
+func (c *ConversationController) AnyMessage_list() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionConversationView); err != nil {
+		return web.JsonError(err)
+	}
+
+	var (
+		conversationID, _ = params.GetInt64(c.Ctx, "conversationId")
+		senderType, _     = params.Get(c.Ctx, "senderType")
+		messageType, _    = params.Get(c.Ctx, "messageType")
+		cursor, _         = params.GetInt64(c.Ctx, "cursor")
+		limit, _          = params.GetInt(c.Ctx, "limit")
+	)
+	if conversation := services.ConversationService.Get(conversationID); conversation == nil {
+		return web.JsonErrorMsg("会话不存在")
+	}
+
+	list, nextCursor, hasMore := services.MessageService.FindByConversationIDCursor(
+		conversationID, cursor, limit, senderType, messageType,
+	)
+	results := builders.BuildMessages(list)
+
+	return web.JsonCursorData(results, cast.ToString(nextCursor), hasMore)
+}
+
+func (c *ConversationController) PostAssign() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionConversationAssign)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.AssignConversationRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.ConversationService.AssignConversation(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *ConversationController) PostDispatch() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionConversationAssign)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.DispatchConversationRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.ConversationService.AutoAssignConversation(req.ConversationID, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *ConversationController) PostTransfer() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionConversationTransfer)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.TransferConversationRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.ConversationService.TransferConversation(req.ConversationID, req.ToUserID, req.Reason, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *ConversationController) PostClose() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionConversationClose)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.CloseConversationRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.ConversationService.CloseConversation(req.ConversationID, req.CloseReason, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *ConversationController) PostLink_customer() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionConversationLinkCustomer)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.LinkConversationCustomerRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.ConversationService.LinkConversationCustomer(req.ConversationID, req.CustomerID, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *ConversationController) PostSend_message() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionConversationSend)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.SendConversationMessageRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.MessageService.SendAgentMessage(req.ConversationID, 0, req.ClientMsgID, req.MessageType, req.Content, req.Payload, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildMessage(item))
+}
+
+func (c *ConversationController) PostRecall_message() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionConversationSend)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.RecallConversationMessageRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.MessageService.RecallAgentMessage(req.MessageID, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildMessage(item))
+}
+
+func (c *ConversationController) PostRead() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionConversationView)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.ReadConversationRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.ConversationService.MarkAgentConversationReadToMessage(req.ConversationID, req.MessageID, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *ConversationController) PostUpload_image() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionConversationSend)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	rawConv := strings.TrimSpace(c.Ctx.FormValue("conversationId"))
+	if rawConv == "" {
+		return web.JsonErrorMsg("conversationId不能为空")
+	}
+	conversationID, err := strconv.ParseInt(rawConv, 10, 64)
+	if err != nil || conversationID <= 0 {
+		return web.JsonErrorMsg("conversationId不能为空")
+	}
+	if _, err := services.MessageService.ValidateConversationSender(conversationID, enums.IMSenderTypeAgent, operator, nil); err != nil {
+		return web.JsonError(err)
+	}
+
+	f, header, err := c.Ctx.FormFile("file")
+	if err != nil {
+		return web.JsonErrorMsg("请选择上传图片")
+	}
+	_ = f.Close()
+
+	if !strings.HasPrefix(strings.ToLower(header.Header.Get("Content-Type")), "image/") {
+		return web.JsonErrorMsg("仅支持上传图片文件")
+	}
+
+	item, err := services.AssetService.UploadFile(header, "images", operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildAsset(item))
+}
+
+func (c *ConversationController) PostUpload_attachment() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionConversationSend)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	rawConv := strings.TrimSpace(c.Ctx.FormValue("conversationId"))
+	if rawConv == "" {
+		return web.JsonErrorMsg("conversationId不能为空")
+	}
+	conversationID, err := strconv.ParseInt(rawConv, 10, 64)
+	if err != nil || conversationID <= 0 {
+		return web.JsonErrorMsg("conversationId不能为空")
+	}
+	if _, err := services.MessageService.ValidateConversationSender(conversationID, enums.IMSenderTypeAgent, operator, nil); err != nil {
+		return web.JsonError(err)
+	}
+
+	f, header, err := c.Ctx.FormFile("file")
+	if err != nil {
+		return web.JsonErrorMsg("请选择上传附件")
+	}
+	_ = f.Close()
+
+	item, err := services.AssetService.UploadFile(header, "attachments", operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildAsset(item))
+}
+
+func (c *ConversationController) PostAdd_tag() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionConversationTag)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.AddConversationTagRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.ConversationTagService.AddTag(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *ConversationController) PostRemove_tag() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionConversationTag); err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.RemoveConversationTagRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.ConversationTagService.RemoveTag(req); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}

internal/controllers/console/customer_contact_controller.go

@@ -0,0 +1,76 @@
+package console
+
+import (
+	"cs-agent/internal/builders"
+	"cs-agent/internal/pkg/constants"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type CustomerContactController struct {
+	Ctx iris.Context
+}
+
+// AnyList GET/POST /customer-contact/list?customerId=
+func (c *CustomerContactController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionCustomerView); err != nil {
+		return web.JsonError(err)
+	}
+	customerID, _ := params.GetInt64(c.Ctx, "customerId")
+	if customerID <= 0 {
+		return web.JsonErrorMsg("customerId 必填")
+	}
+	list := services.CustomerContactService.FindActiveByCustomerID(customerID)
+	return web.JsonData(builders.BuildCustomerContactList(list))
+}
+
+func (c *CustomerContactController) PostCreate() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionCustomerUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.CreateCustomerContactRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.CustomerContactService.CreateCustomerContact(req, user)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	ret := builders.BuildCustomerContactResponse(item)
+	return web.JsonData(&ret)
+}
+
+func (c *CustomerContactController) PostUpdate() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionCustomerUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.UpdateCustomerContactRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.CustomerContactService.UpdateCustomerContact(req, user); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *CustomerContactController) PostDelete() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionCustomerUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.DeleteCustomerContactRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.CustomerContactService.DeleteCustomerContact(req.ID, user); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}

internal/controllers/console/customer_controller.go

@@ -0,0 +1,129 @@
+package console
+
+import (
+	"cs-agent/internal/builders"
+	"cs-agent/internal/pkg/constants"
+	"cs-agent/internal/pkg/dto"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/pkg/enums"
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type CustomerController struct {
+	Ctx iris.Context
+}
+
+func (c *CustomerController) PostList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionCustomerView); err != nil {
+		return web.JsonError(err)
+	}
+	var req request.CustomerListRequest
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	list, paging := services.CustomerService.ListCustomers(req)
+	return web.JsonData(&web.PageResult{Results: builders.BuildCustomerList(list), Page: paging})
+}
+
+func (c *CustomerController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionCustomerView); err != nil {
+		return web.JsonError(err)
+	}
+	item := services.CustomerService.Get(id)
+	if item == nil || item.Status == enums.StatusDeleted {
+		return web.JsonData(nil)
+	}
+	ret := builders.BuildCustomer(item)
+	return web.JsonData(&ret)
+}
+
+// PostSave_profile POST /save_profile — 客户主信息与联系方式在同一事务中保存。
+func (c *CustomerController) PostSave_profile() *web.JsonResult {
+	req := request.SaveCustomerProfileRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	createMode := req.ID == nil || *req.ID <= 0
+	var user *dto.AuthPrincipal
+	var err error
+	if createMode {
+		user, err = services.AuthService.RequirePermission(c.Ctx, constants.PermissionCustomerCreate)
+	} else {
+		user, err = services.AuthService.RequirePermission(c.Ctx, constants.PermissionCustomerUpdate)
+	}
+	if err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.CustomerService.SaveCustomerProfile(req, user)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	ret := builders.BuildCustomer(item)
+	return web.JsonData(&ret)
+}
+
+func (c *CustomerController) PostCreate() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionCustomerCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.CreateCustomerRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.CustomerService.CreateCustomer(req, user)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	ret := builders.BuildCustomer(item)
+	return web.JsonData(&ret)
+}
+
+func (c *CustomerController) PostUpdate() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionCustomerUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.UpdateCustomerRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.CustomerService.UpdateCustomer(req, user); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *CustomerController) PostDelete() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionCustomerDelete)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.DeleteCustomerRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.CustomerService.DeleteCustomer(req.ID, *user); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *CustomerController) PostUpdate_status() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionCustomerUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.UpdateCustomerStatusRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.CustomerService.UpdateStatus(req.ID, req.Status, user); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}

internal/controllers/console/dashboard_controller.go

@@ -0,0 +1,18 @@
+package console
+
+import (
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type DashboardController struct {
+	Ctx iris.Context
+}
+
+func (c *DashboardController) GetOverview() *web.JsonResult {
+	rangeValue, _ := params.Get(c.Ctx, "range")
+	return web.JsonData(services.DashboardService.GetOverview(rangeValue))
+}

internal/controllers/console/knowledge_base_controller.go

@@ -0,0 +1,164 @@
+package console
+
+import (
+	"context"
+	"log/slog"
+
+	"cs-agent/internal/ai/rag"
+	"cs-agent/internal/builders"
+	"cs-agent/internal/pkg/constants"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/pkg/dto/response"
+	"cs-agent/internal/repositories"
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/sqls"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type KnowledgeBaseController struct {
+	Ctx iris.Context
+}
+
+func (c *KnowledgeBaseController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeBaseView); err != nil {
+		return web.JsonError(err)
+	}
+
+	cnd := params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "status"},
+		params.QueryFilter{ParamName: "name", Op: params.Like},
+	).Asc("sort_no").Desc("id")
+	list, paging := services.KnowledgeBaseService.FindPageByCnd(cnd)
+	results := make([]response.KnowledgeBaseResponse, 0, len(list))
+	for _, item := range list {
+		docCount := repositories.KnowledgeDocumentRepository.CountByKnowledgeBaseID(sqls.DB(), item.ID)
+		faqCount := repositories.KnowledgeFAQRepository.CountByKnowledgeBaseID(sqls.DB(), item.ID)
+		resp := builders.BuildKnowledgeBase(&item)
+		resp.DocumentCount = docCount
+		resp.FAQCount = faqCount
+		results = append(results, resp)
+	}
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *KnowledgeBaseController) AnyList_all() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeBaseView); err != nil {
+		return web.JsonError(err)
+	}
+
+	list := services.KnowledgeBaseService.Find(params.NewSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "status"},
+	).Asc("sort_no").Desc("id"))
+	results := make([]response.KnowledgeBaseResponse, 0, len(list))
+	for _, item := range list {
+		resp := builders.BuildKnowledgeBase(&item)
+		results = append(results, resp)
+	}
+	return web.JsonData(results)
+}
+
+func (c *KnowledgeBaseController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeBaseView); err != nil {
+		return web.JsonError(err)
+	}
+
+	item := services.KnowledgeBaseService.Get(id)
+	if item == nil {
+		return web.JsonErrorMsg("知识库不存在")
+	}
+	resp := builders.BuildKnowledgeBase(item)
+	resp.DocumentCount = repositories.KnowledgeDocumentRepository.CountByKnowledgeBaseID(sqls.DB(), item.ID)
+	resp.FAQCount = repositories.KnowledgeFAQRepository.CountByKnowledgeBaseID(sqls.DB(), item.ID)
+	return web.JsonData(resp)
+}
+
+func (c *KnowledgeBaseController) PostCreate() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeBaseCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.CreateKnowledgeBaseRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.KnowledgeBaseService.CreateKnowledgeBase(req, user)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildKnowledgeBase(item))
+}
+
+func (c *KnowledgeBaseController) PostUpdate() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeBaseUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.UpdateKnowledgeBaseRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.KnowledgeBaseService.UpdateKnowledgeBase(req, user); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *KnowledgeBaseController) PostDelete() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeBaseDelete); err != nil {
+		return web.JsonError(err)
+	}
+
+	var req struct {
+		ID int64 `json:"id"`
+	}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.KnowledgeBaseService.DeleteKnowledgeBase(req.ID); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *KnowledgeBaseController) PostUpdate_sort() *web.JsonResult {
+	var ids []int64
+	if err := c.Ctx.ReadJSON(&ids); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.KnowledgeBaseService.UpdateSort(ids); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *KnowledgeBaseController) PostRebuild_index() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeBaseUpdate); err != nil {
+		return web.JsonError(err)
+	}
+
+	var req struct {
+		ID int64 `json:"id"`
+	}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+
+	knowledgeBase := services.KnowledgeBaseService.Get(req.ID)
+	if knowledgeBase == nil {
+		return web.JsonErrorMsg("知识库不存在")
+	}
+
+	go func() {
+		ctx := context.Background()
+		if err := rag.Index.RebuildKnowledgeBaseIndex(ctx, req.ID); err != nil {
+			slog.Error("Failed to rebuild knowledge base index", "knowledge_base_id", req.ID, "error", err)
+		}
+	}()
+
+	return web.JsonSuccess()
+}

internal/controllers/console/knowledge_document_controller.go

@@ -0,0 +1,111 @@
+package console
+
+import (
+	"cs-agent/internal/builders"
+	"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/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type KnowledgeDocumentController struct {
+	Ctx iris.Context
+}
+
+func (c *KnowledgeDocumentController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeDocumentView); err != nil {
+		return web.JsonError(err)
+	}
+
+	cnd := params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "knowledgeBaseId"},
+		params.QueryFilter{ParamName: "title", Op: params.Like},
+	).Desc("id")
+
+	if status, ok := params.GetInt64(c.Ctx, "status"); ok {
+		cnd.Where("status = ?", status)
+	} else {
+		cnd.Where("status != ?", enums.StatusDeleted)
+	}
+	if indexStatus, ok := params.Get(c.Ctx, "indexStatus"); ok {
+		if !enums.IsValidKnowledgeDocumentIndexStatus(indexStatus) {
+			return web.JsonErrorMsg("indexStatus参数不合法")
+		}
+		cnd.Where("index_status = ?", indexStatus)
+	}
+
+	list, paging := services.KnowledgeDocumentService.FindPageByCnd(cnd)
+	results := make([]response.KnowledgeDocumentResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, builders.BuildKnowledgeDocument(&item))
+	}
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *KnowledgeDocumentController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeDocumentView); err != nil {
+		return web.JsonError(err)
+	}
+
+	item := services.KnowledgeDocumentService.Get(id)
+	if item == nil {
+		return web.JsonErrorMsg("文档不存在")
+	}
+	return web.JsonData(builders.BuildKnowledgeDocument(item))
+}
+
+func (c *KnowledgeDocumentController) PostCreate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeDocumentCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.CreateKnowledgeDocumentRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.KnowledgeDocumentService.CreateKnowledgeDocument(req, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildKnowledgeDocument(item))
+}
+
+func (c *KnowledgeDocumentController) PostUpdate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeDocumentUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.UpdateKnowledgeDocumentRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.KnowledgeDocumentService.UpdateKnowledgeDocument(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *KnowledgeDocumentController) PostDelete() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeDocumentDelete); err != nil {
+		return web.JsonError(err)
+	}
+
+	var req struct {
+		ID int64 `json:"id"`
+	}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+
+	if err := services.KnowledgeDocumentService.DeleteKnowledgeDocument(req.ID); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}

internal/controllers/console/knowledge_faq_controller.go

@@ -0,0 +1,94 @@
+package console
+
+import (
+	"cs-agent/internal/builders"
+	"cs-agent/internal/pkg/constants"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/pkg/dto/response"
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type KnowledgeFAQController struct {
+	Ctx iris.Context
+}
+
+func (c *KnowledgeFAQController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeFAQView); err != nil {
+		return web.JsonError(err)
+	}
+
+	cnd := params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "knowledgeBaseId"},
+		params.QueryFilter{ParamName: "question", Op: params.Like},
+		params.QueryFilter{ParamName: "indexStatus"},
+	).Desc("id")
+	list, paging := services.KnowledgeFAQService.FindPageByCnd(cnd)
+	results := make([]response.KnowledgeFAQResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, builders.BuildKnowledgeFAQ(&item))
+	}
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *KnowledgeFAQController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeFAQView); err != nil {
+		return web.JsonError(err)
+	}
+
+	item := services.KnowledgeFAQService.Get(id)
+	if item == nil {
+		return web.JsonErrorMsg("FAQ不存在")
+	}
+	return web.JsonData(builders.BuildKnowledgeFAQ(item))
+}
+
+func (c *KnowledgeFAQController) PostCreate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeFAQCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.CreateKnowledgeFAQRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.KnowledgeFAQService.CreateKnowledgeFAQ(req, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildKnowledgeFAQ(item))
+}
+
+func (c *KnowledgeFAQController) PostUpdate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeFAQUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.UpdateKnowledgeFAQRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.KnowledgeFAQService.UpdateKnowledgeFAQ(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *KnowledgeFAQController) PostDelete() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeFAQDelete); err != nil {
+		return web.JsonError(err)
+	}
+	var req struct {
+		ID int64 `json:"id"`
+	}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.KnowledgeFAQService.DeleteKnowledgeFAQ(req.ID); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}

internal/controllers/console/knowledge_retrieve_controller.go

@@ -0,0 +1,85 @@
+package console
+
+import (
+	"context"
+
+	"cs-agent/internal/ai/rag"
+	"cs-agent/internal/pkg/constants"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type KnowledgeRetrieveController struct {
+	Ctx iris.Context
+}
+
+func (c *KnowledgeRetrieveController) PostDebugSearch() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeDocumentView); err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.KnowledgeSearchRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+
+	resp, err := rag.Answer.DebugSearch(context.Background(), req)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(resp)
+}
+
+func (c *KnowledgeRetrieveController) PostDebugAnswer() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeDocumentView)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.KnowledgeAnswerRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+
+	resp, err := rag.Answer.DebugAnswer(context.Background(), req, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(resp)
+}
+
+func (c *KnowledgeRetrieveController) PostBuild() *web.JsonResult {
+	req := struct {
+		DocumentID int64 `json:"documentId"`
+		FAQID      int64 `json:"faqId"`
+	}{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+
+	if req.DocumentID > 0 {
+		if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeDocumentUpdate); err != nil {
+			return web.JsonError(err)
+		}
+		if err := rag.Answer.BuildDocumentIndex(context.Background(), req.DocumentID); err != nil {
+			return web.JsonError(err)
+		}
+		return web.JsonSuccess()
+	}
+
+	if req.FAQID > 0 {
+		if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeFAQUpdate); err != nil {
+			return web.JsonError(err)
+		}
+		if err := rag.Index.IndexFAQByID(context.Background(), req.FAQID); err != nil {
+			return web.JsonError(err)
+		}
+		return web.JsonSuccess()
+	}
+
+	return web.JsonErrorMsg("documentId或faqId不能为空")
+}

internal/controllers/console/knowledge_retrieve_log_controller.go

@@ -0,0 +1,77 @@
+package console
+
+import (
+	"cs-agent/internal/builders"
+	"cs-agent/internal/pkg/constants"
+	"cs-agent/internal/pkg/dto/response"
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type KnowledgeRetrieveLogController struct {
+	Ctx iris.Context
+}
+
+func (c *KnowledgeRetrieveLogController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeDocumentView); err != nil {
+		return web.JsonError(err)
+	}
+
+	cnd := params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "knowledgeBaseId"},
+		params.QueryFilter{ParamName: "question", Op: params.Like},
+		params.QueryFilter{ParamName: "channel"},
+		params.QueryFilter{ParamName: "scene"},
+		params.QueryFilter{ParamName: "chunkProvider"},
+	).Desc("id")
+
+	if answerStatus, ok := params.GetInt64(c.Ctx, "answerStatus"); ok && answerStatus > 0 {
+		cnd.Where("answer_status = ?", answerStatus)
+	}
+	if rerankEnabled, ok := params.GetInt64(c.Ctx, "rerankEnabled"); ok {
+		cnd.Where("rerank_enabled = ?", rerankEnabled > 0)
+	}
+
+	queryParams := params.NewQueryParams(c.Ctx)
+	queryParams.Cnd = *cnd
+	list, paging := services.KnowledgeRetrieveLogService.FindPageByParams(queryParams)
+	results := make([]response.KnowledgeRetrieveLogResponse, 0, len(list))
+	for _, item := range list {
+		resp := builders.BuildKnowledgeRetrieveLog(&item)
+		if knowledgeBase := services.KnowledgeBaseService.Get(item.KnowledgeBaseID); knowledgeBase != nil {
+			resp.KnowledgeBaseName = knowledgeBase.Name
+		}
+		results = append(results, resp)
+	}
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *KnowledgeRetrieveLogController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionKnowledgeDocumentView); err != nil {
+		return web.JsonError(err)
+	}
+
+	logItem := services.KnowledgeRetrieveLogService.Get(id)
+	if logItem == nil {
+		return web.JsonErrorMsg("检索日志不存在")
+	}
+
+	logResp := builders.BuildKnowledgeRetrieveLog(logItem)
+	if knowledgeBase := services.KnowledgeBaseService.Get(logItem.KnowledgeBaseID); knowledgeBase != nil {
+		logResp.KnowledgeBaseName = knowledgeBase.Name
+	}
+
+	hits := services.KnowledgeRetrieveLogService.FindHitsByRetrieveLogID(id)
+	hitResults := make([]response.KnowledgeRetrieveHitResponse, 0, len(hits))
+	for _, item := range hits {
+		hitResults = append(hitResults, builders.BuildKnowledgeRetrieveHitResponse(&item))
+	}
+
+	return web.JsonData(response.KnowledgeRetrieveLogDetailResponse{
+		Log:  logResp,
+		Hits: hitResults,
+	})
+}

internal/controllers/console/mcp_controller.go

@@ -0,0 +1,70 @@
+package console
+
+import (
+	"context"
+
+	"cs-agent/internal/pkg/constants"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/pkg/dto/response"
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type MCPController struct {
+	Ctx iris.Context
+}
+
+func (c *MCPController) AnyList_servers() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionMCPView); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(response.BuildMCPServerInfoResponses(services.MCPDebugService.ListServers()))
+}
+
+func (c *MCPController) PostTest_connection() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionMCPView); err != nil {
+		return web.JsonError(err)
+	}
+	req := request.MCPServerDebugRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	result, err := services.MCPDebugService.TestConnection(context.Background(), req.ServerCode)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(response.BuildMCPConnectionResponse(result))
+}
+
+func (c *MCPController) PostList_tools() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionMCPView); err != nil {
+		return web.JsonError(err)
+	}
+	req := request.MCPServerDebugRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	result, err := services.MCPDebugService.ListTools(context.Background(), req.ServerCode)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(response.BuildMCPToolInfoResponses(result))
+}
+
+func (c *MCPController) PostCall_tool() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionMCPCall); err != nil {
+		return web.JsonError(err)
+	}
+	req := request.MCPCallToolRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	result, err := services.MCPDebugService.CallTool(context.Background(), req.ServerCode, req.ToolName, req.Arguments)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(response.BuildMCPCallToolResponse(result))
+}

internal/controllers/console/permission_controller.go

@@ -0,0 +1,71 @@
+package console
+
+import (
+	"cs-agent/internal/pkg/constants"
+	"cs-agent/internal/pkg/dto/response"
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/common/strs"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type PermissionController struct {
+	Ctx iris.Context
+}
+
+func (c *PermissionController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionPermissionView); err != nil {
+		return web.JsonError(err)
+	}
+
+	cnd := params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "groupName"},
+		params.QueryFilter{ParamName: "type"},
+		params.QueryFilter{ParamName: "status"},
+	).Desc("id")
+
+	if keyword, _ := params.Get(c.Ctx, "keyword"); strs.IsNotBlank(keyword) {
+		cnd.Where("(name LIKE ? OR code LIKE ?)", "%"+keyword+"%", "%"+keyword+"%")
+	}
+
+	list, paging := services.PermissionService.FindPageByCnd(cnd)
+	results := make([]response.PermissionResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, response.PermissionResponse{
+			ID:        item.ID,
+			Name:      item.Name,
+			Code:      item.Code,
+			Type:      item.Type,
+			GroupName: item.GroupName,
+			Method:    item.Method,
+			ApiPath:   item.APIPath,
+			Status:    item.Status,
+			SortNo:    item.SortNo,
+		})
+	}
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *PermissionController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionPermissionView); err != nil {
+		return web.JsonError(err)
+	}
+
+	item := services.PermissionService.Get(id)
+	if item == nil {
+		return web.JsonErrorMsg("权限不存在")
+	}
+	return web.JsonData(&response.PermissionResponse{
+		ID:        item.ID,
+		Name:      item.Name,
+		Code:      item.Code,
+		Type:      item.Type,
+		GroupName: item.GroupName,
+		Method:    item.Method,
+		ApiPath:   item.APIPath,
+		Status:    item.Status,
+		SortNo:    item.SortNo,
+	})
+}

internal/controllers/console/quick_reply_controller.go

@@ -0,0 +1,118 @@
+package console
+
+import (
+	"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/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/sqls"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type QuickReplyController struct {
+	Ctx iris.Context
+}
+
+func (c *QuickReplyController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionQuickReplyView); err != nil {
+		return web.JsonError(err)
+	}
+
+	cnd := params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "status"},
+		params.QueryFilter{ParamName: "groupName"},
+		params.QueryFilter{ParamName: "title", Op: params.Like},
+	).Asc("sort_no").Desc("id")
+
+	list, paging := services.QuickReplyService.FindPageByCnd(cnd)
+	results := make([]response.QuickReplyResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, response.QuickReplyResponse{
+			ID:        item.ID,
+			GroupName: item.GroupName,
+			Title:     item.Title,
+			Content:   item.Content,
+			Status:    item.Status,
+			SortNo:    item.SortNo,
+		})
+	}
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *QuickReplyController) GetList_all() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionQuickReplyView); err != nil {
+		return web.JsonError(err)
+	}
+	list := services.QuickReplyService.Find(sqls.NewCnd().Eq("status", enums.StatusOk).Asc("sort_no").Desc("id"))
+	results := make([]response.QuickReplyResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, response.QuickReplyResponse{
+			ID:        item.ID,
+			GroupName: item.GroupName,
+			Title:     item.Title,
+			Content:   item.Content,
+			Status:    item.Status,
+			SortNo:    item.SortNo,
+		})
+	}
+	return web.JsonData(results)
+}
+
+func (c *QuickReplyController) PostCreate() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionQuickReplyCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.CreateQuickReplyRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.QuickReplyService.CreateQuickReply(req, user)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(&response.QuickReplyResponse{
+		ID:        item.ID,
+		GroupName: item.GroupName,
+		Title:     item.Title,
+		Content:   item.Content,
+		Status:    item.Status,
+		SortNo:    item.SortNo,
+	})
+}
+
+func (c *QuickReplyController) PostUpdate() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionQuickReplyUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.UpdateQuickReplyRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.QuickReplyService.UpdateQuickReply(req, user); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *QuickReplyController) PostDelete() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionQuickReplyDelete); err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.DeleteQuickReplyRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.QuickReplyService.DeleteQuickReply(req.ID); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}

internal/controllers/console/role_controller.go

@@ -0,0 +1,187 @@
+package console
+
+import (
+	"cs-agent/internal/pkg/constants"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/pkg/dto/response"
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/sqls"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type RoleController struct {
+	Ctx iris.Context
+}
+
+func (c *RoleController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionRoleView); err != nil {
+		return web.JsonError(err)
+	}
+	cnd := params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "status"},
+		params.QueryFilter{ParamName: "code", Op: params.Like},
+	).Asc("sort_no").Desc("id")
+	list, paging := services.RoleService.FindPageByCnd(cnd)
+	results := make([]response.RoleResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, response.RoleResponse{
+			ID:       item.ID,
+			Name:     item.Name,
+			Code:     item.Code,
+			Status:   item.Status,
+			IsSystem: item.IsSystem,
+			SortNo:   item.SortNo,
+		})
+	}
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *RoleController) GetList_all() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionRoleView); err != nil {
+		return web.JsonError(err)
+	}
+
+	list := services.RoleService.Find(sqls.NewCnd().Asc("sort_no").Desc("id"))
+	results := make([]response.RoleResponse, 0, len(list))
+	for _, item := range list {
+		results = append(results, response.RoleResponse{
+			ID:       item.ID,
+			Name:     item.Name,
+			Code:     item.Code,
+			Status:   item.Status,
+			IsSystem: item.IsSystem,
+			SortNo:   item.SortNo,
+		})
+	}
+	return web.JsonData(results)
+}
+
+func (c *RoleController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionRoleView); err != nil {
+		return web.JsonError(err)
+	}
+
+	item := services.RoleService.Get(id)
+	if item == nil {
+		return web.JsonErrorMsg("角色不存在")
+	}
+
+	permissionCodes := make([]string, 0)
+	list := services.RolePermissionService.Find(sqls.NewCnd().Eq("role_id", item.ID))
+	for _, relation := range list {
+		permission := services.PermissionService.Get(relation.PermissionID)
+		if permission != nil {
+			permissionCodes = append(permissionCodes, permission.Code)
+		}
+	}
+	return web.JsonData(&response.RoleResponse{
+		ID:          item.ID,
+		Name:        item.Name,
+		Code:        item.Code,
+		Status:      item.Status,
+		IsSystem:    item.IsSystem,
+		SortNo:      item.SortNo,
+		Permissions: permissionCodes,
+	})
+}
+
+func (c *RoleController) PostCreate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionRoleCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.CreateRoleRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	role, err := services.RoleService.CreateRole(req, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(&response.RoleResponse{
+		ID:       role.ID,
+		Name:     role.Name,
+		Code:     role.Code,
+		Status:   role.Status,
+		IsSystem: role.IsSystem,
+		SortNo:   role.SortNo,
+	})
+}
+
+func (c *RoleController) PostUpdate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionRoleUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.UpdateRoleRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.RoleService.UpdateRole(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *RoleController) PostDelete() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionRoleDelete); err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.DeleteRoleRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.RoleService.DeleteRole(req.ID); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *RoleController) PostUpdate_status() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionRoleUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.UpdateRoleStatusRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.RoleService.UpdateStatus(req.ID, req.Status, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *RoleController) PostAssign_permission() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionRoleAssignPermission)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.AssignPermissionRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.RoleService.AssignPermissions(req.RoleID, req.PermissionIDs, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *RoleController) PostUpdate_sort() *web.JsonResult {
+	var ids []int64
+	if err := c.Ctx.ReadJSON(&ids); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.RoleService.UpdateSort(ids); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}

internal/controllers/console/session_controller.go

@@ -0,0 +1,83 @@
+package console
+
+import (
+	"cs-agent/internal/pkg/constants"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/pkg/dto/response"
+	"cs-agent/internal/pkg/utils"
+	"cs-agent/internal/services"
+	"time"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type SessionController struct {
+	Ctx iris.Context
+}
+
+func (c *SessionController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionSessionView); err != nil {
+		return web.JsonError(err)
+	}
+
+	cnd := params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "userId"},
+		params.QueryFilter{ParamName: "tokenType"},
+		params.QueryFilter{ParamName: "clientType"},
+	).Desc("id")
+	list, paging := services.LoginSessionService.FindPageByCnd(cnd)
+	results := make([]response.SessionResponse, 0, len(list))
+	for _, item := range list {
+		username := ""
+		if user := services.UserService.Get(item.UserID); user != nil {
+			username = user.Username
+		}
+		results = append(results, response.SessionResponse{
+			ID:         item.ID,
+			UserID:     item.UserID,
+			Username:   username,
+			TokenType:  item.TokenType,
+			ClientType: item.ClientType,
+			ClientIP:   item.ClientIP,
+			UserAgent:  item.UserAgent,
+			ExpiredAt:  item.ExpiredAt.Format(time.DateTime),
+			RevokedAt:  utils.FormatTimePtr(item.RevokedAt),
+			LastSeenAt: utils.FormatTimePtr(item.LastSeenAt),
+		})
+	}
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *SessionController) PostRevoke() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionSessionRevoke)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.RevokeSessionRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.LoginSessionService.Revoke(req.ID, user.UserID, user.Username); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *SessionController) PostRevokeByUser() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionSessionRevoke)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.RevokeUserSessionsRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.LoginSessionService.RevokeByUser(req.UserID, user.UserID, user.Username); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}

internal/controllers/console/skill_definition_controller.go

@@ -0,0 +1,280 @@
+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)
+}

internal/controllers/console/tag_controller.go

@@ -0,0 +1,127 @@
+package console
+
+import (
+	"cs-agent/internal/builders"
+	"cs-agent/internal/pkg/constants"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type TagController struct {
+	Ctx iris.Context
+}
+
+func (c *TagController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTagView); err != nil {
+		return web.JsonError(err)
+	}
+	list, paging := services.TagService.FindPageByCnd(params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "status"},
+		params.QueryFilter{ParamName: "parentId"},
+		params.QueryFilter{ParamName: "name", Op: params.Like},
+	).Asc("sort_no").Desc("id"))
+	results := builders.BuildTagResponses(list)
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *TagController) GetList_all() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTagView); err != nil {
+		return web.JsonError(err)
+	}
+	list := services.TagService.FindAll()
+	results := builders.BuildTagTreeResponses(list)
+	return web.JsonData(results)
+}
+
+func (c *TagController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTagView); err != nil {
+		return web.JsonError(err)
+	}
+
+	item := services.TagService.Get(id)
+	if item == nil {
+		return web.JsonErrorMsg("标签不存在")
+	}
+	result := builders.BuildTagResponse(item)
+	return web.JsonData(&result)
+}
+
+func (c *TagController) PostCreate() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTagCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.CreateTagRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.TagService.CreateTag(req, user)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	result := builders.BuildTagResponse(item)
+	return web.JsonData(&result)
+}
+
+func (c *TagController) PostUpdate() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTagUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.UpdateTagRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TagService.UpdateTag(req, user); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TagController) PostDelete() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTagDelete); err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.DeleteTagRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TagService.DeleteTag(req.ID); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TagController) PostUpdate_sort() *web.JsonResult {
+	var ids []int64
+	if err := c.Ctx.ReadJSON(&ids); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TagService.UpdateSort(ids); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TagController) PostUpdate_status() *web.JsonResult {
+	user, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTagUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.UpdateTagStatusRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TagService.UpdateStatus(req.ID, req.Status, user); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}

internal/controllers/console/ticket_controller.go

@@ -0,0 +1,501 @@
+package console
+
+import (
+	"strings"
+	"time"
+
+	"cs-agent/internal/builders"
+	"cs-agent/internal/pkg/constants"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/pkg/enums"
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type TicketController struct {
+	Ctx iris.Context
+}
+
+func (c *TicketController) AnyList() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketView)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	cnd := params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "status"},
+		params.QueryFilter{ParamName: "priority"},
+		params.QueryFilter{ParamName: "severity"},
+		params.QueryFilter{ParamName: "currentTeamId"},
+		params.QueryFilter{ParamName: "currentAssigneeId"},
+		params.QueryFilter{ParamName: "customerId"},
+		params.QueryFilter{ParamName: "conversationId"},
+		params.QueryFilter{ParamName: "source"},
+	).Desc("updated_at").Desc("id")
+	if keyword, _ := params.Get(c.Ctx, "keyword"); strings.TrimSpace(keyword) != "" {
+		keyword = "%" + strings.TrimSpace(keyword) + "%"
+		cnd.Where("ticket_no LIKE ? OR title LIKE ? OR description LIKE ?", keyword, keyword, keyword)
+	}
+	if tagID, _ := params.GetInt64(c.Ctx, "tagId"); tagID > 0 {
+		cnd.Where("id IN (SELECT ticket_id FROM t_ticket_tag WHERE tag_id = ?)", tagID)
+	}
+	if watching, _ := params.Get(c.Ctx, "watching"); watching == "1" || strings.EqualFold(watching, "true") {
+		cnd.Where("id IN (SELECT ticket_id FROM t_ticket_watcher WHERE user_id = ?)", operator.UserID)
+	}
+	if collaborating, _ := params.Get(c.Ctx, "collaborating"); collaborating == "1" || strings.EqualFold(collaborating, "true") {
+		cnd.Where("id IN (SELECT ticket_id FROM t_ticket_collaborator WHERE user_id = ?)", operator.UserID)
+	}
+	if collaboration, _ := params.Get(c.Ctx, "collaboration"); collaboration == "1" || strings.EqualFold(collaboration, "true") {
+		cnd.Where(
+			"(id IN (SELECT ticket_id FROM t_ticket_collaborator WHERE user_id = ?) OR id IN (SELECT ticket_id FROM t_ticket_mention WHERE mentioned_user_id = ?))",
+			operator.UserID,
+			operator.UserID,
+		)
+	}
+	if mentioned, _ := params.Get(c.Ctx, "mentioned"); mentioned == "1" || strings.EqualFold(mentioned, "true") {
+		cnd.Where("id IN (SELECT ticket_id FROM t_ticket_mention WHERE mentioned_user_id = ?)", operator.UserID)
+	}
+	if mine, _ := params.Get(c.Ctx, "mine"); mine == "1" || strings.EqualFold(mine, "true") {
+		cnd.Eq("current_assignee_id", operator.UserID)
+	}
+	if unassigned, _ := params.Get(c.Ctx, "unassigned"); unassigned == "1" || strings.EqualFold(unassigned, "true") {
+		cnd.Eq("current_assignee_id", 0)
+	}
+	if overdue, _ := params.Get(c.Ctx, "overdue"); overdue == "1" || strings.EqualFold(overdue, "true") {
+		cnd.In("status", []string{"new", "open", "pending_customer", "pending_internal"})
+		cnd.Where("resolve_deadline_at IS NOT NULL")
+		cnd.Where("resolve_deadline_at < ?", time.Now())
+	}
+	aggregate, err := services.TicketService.FindPageAggregateByCnd(cnd, operator.UserID)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(&web.PageResult{
+		Results: builders.BuildTicketListWithContext(aggregate.List, &builders.TicketBuildContext{
+			TagsByTicketID:   aggregate.TagsByTicketID,
+			Priorities:       aggregate.Priorities,
+			ResolutionCodes:  aggregate.ResolutionCodes,
+			Users:            aggregate.Users,
+			Teams:            aggregate.Teams,
+			Customers:        aggregate.Customers,
+			SLAByTicketID:    aggregate.SLAByTicketID,
+			WatchedTicketIDs: aggregate.WatchedTicketIDs,
+		}),
+		Page: aggregate.Paging,
+	})
+}
+
+func (c *TicketController) AnySummary() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketView)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildTicketSummary(services.TicketService.GetSummary(operator)))
+}
+
+func (c *TicketController) AnyRisk_overview() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketView); err != nil {
+		return web.JsonError(err)
+	}
+	teamID, _ := params.GetInt64(c.Ctx, "currentTeamId")
+	riskWindowMins, _ := params.GetInt(c.Ctx, "riskWindowMins")
+	return web.JsonData(builders.BuildTicketRiskOverview(services.TicketService.GetRiskOverview(teamID, riskWindowMins)))
+}
+
+func (c *TicketController) AnyRisk_list() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketView)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	riskType, _ := params.Get(c.Ctx, "riskType")
+	teamID, _ := params.GetInt64(c.Ctx, "currentTeamId")
+	riskWindowMins, _ := params.GetInt(c.Ctx, "riskWindowMins")
+	page, _ := params.GetInt(c.Ctx, "page")
+	limit, _ := params.GetInt(c.Ctx, "limit")
+	aggregate, err := services.TicketService.GetRiskPageAggregate(riskType, teamID, riskWindowMins, page, limit, operator.UserID)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(&web.PageResult{
+		Results: builders.BuildTicketListWithContext(aggregate.List, &builders.TicketBuildContext{
+			TagsByTicketID:   aggregate.TagsByTicketID,
+			Priorities:       aggregate.Priorities,
+			ResolutionCodes:  aggregate.ResolutionCodes,
+			Users:            aggregate.Users,
+			Teams:            aggregate.Teams,
+			Customers:        aggregate.Customers,
+			SLAByTicketID:    aggregate.SLAByTicketID,
+			WatchedTicketIDs: aggregate.WatchedTicketIDs,
+		}),
+		Page: aggregate.Paging,
+	})
+}
+
+func (c *TicketController) AnyView_list() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketView)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildTicketViewList(services.TicketViewService.ListByUser(operator.UserID)))
+}
+
+func (c *TicketController) PostSave_view() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketView)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.SaveTicketViewRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.TicketViewService.Save(req, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildTicketView(item))
+}
+
+func (c *TicketController) PostDelete_view() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketView)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.DeleteTicketViewRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketViewService.Delete(req.ID, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketView); err != nil {
+		return web.JsonError(err)
+	}
+	detail, err := services.TicketService.GetDetail(id)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildTicketDetail(detail))
+}
+
+func (c *TicketController) PostCreate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.CreateTicketRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.TicketService.CreateTicket(req, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildTicket(item))
+}
+
+func (c *TicketController) PostCreate_from_conversation() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.CreateTicketFromConversationRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.TicketService.CreateFromConversation(req, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildTicket(item))
+}
+
+func (c *TicketController) PostUpdate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.UpdateTicketRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketService.UpdateTicket(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketController) PostLink_customer() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.LinkTicketCustomerRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketService.LinkTicketCustomer(req.TicketID, req.CustomerID, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketController) PostAssign() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketAssign)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.AssignTicketRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketService.AssignTicket(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketController) PostBatch_assign() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketAssign)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.BatchAssignTicketRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketService.BatchAssignTickets(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketController) PostChange_status() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketChangeStatus)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.ChangeTicketStatusRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketService.ChangeStatus(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketController) PostBatch_change_status() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketChangeStatus)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.BatchChangeTicketStatusRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketService.BatchChangeStatus(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketController) PostReply() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketReply)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.ReplyTicketRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.TicketService.ReplyTicket(req, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildTicketComment(item))
+}
+
+func (c *TicketController) PostInternal_note() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketReply)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.InternalNoteRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.TicketService.AddInternalNote(req, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildTicketComment(item))
+}
+
+func (c *TicketController) PostClose() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketClose)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.CloseTicketRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketService.CloseTicket(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketController) PostReopen() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketReopen)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.ReopenTicketRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketService.ReopenTicket(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketController) PostWatch() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketView)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.WatchTicketRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketService.WatchTicket(req.TicketID, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketController) PostUnwatch() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketView)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.WatchTicketRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketService.UnwatchTicket(req.TicketID, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketController) PostBatch_watch() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketView)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.BatchWatchTicketRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketService.BatchWatchTickets(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketController) PostAdd_relation() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.AddTicketRelationRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	relatedTicketID := req.RelatedTicketID
+	if relatedTicketID <= 0 && strings.TrimSpace(req.RelatedTicketNo) != "" {
+		if relatedTicket := services.TicketService.Take("ticket_no = ?", strings.TrimSpace(req.RelatedTicketNo)); relatedTicket != nil {
+			relatedTicketID = relatedTicket.ID
+		}
+	}
+	if err := services.TicketRelationService.AddRelation(req.TicketID, relatedTicketID, enums.TicketRelationType(strings.TrimSpace(req.RelationType)), operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketController) PostDelete_relation() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.DeleteTicketRelationRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketRelationService.DeleteRelation(req.TicketID, req.RelationID, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketController) PostAdd_collaborator() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.AddTicketCollaboratorRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketService.AddCollaborator(req.TicketID, req.UserID, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketController) PostDelete_collaborator() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.DeleteTicketCollaboratorRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketService.RemoveCollaborator(req.TicketID, req.CollaboratorID, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketController) AnyComment_list() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketView); err != nil {
+		return web.JsonError(err)
+	}
+	ticketID, _ := params.GetInt64(c.Ctx, "ticketId")
+	if ticketID <= 0 {
+		return web.JsonData(&web.PageResult{Results: []any{}, Page: params.GetPaging(c.Ctx)})
+	}
+	cnd := params.NewPagedSqlCnd(c.Ctx, params.QueryFilter{ParamName: "ticketId"}).Asc("id")
+	results, paging := services.TicketCommentService.FindPageByCnd(cnd)
+	return web.JsonData(&web.PageResult{Results: builders.BuildTicketCommentList(results), Page: paging})
+}
+
+func (c *TicketController) AnyEvent_list() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketView); err != nil {
+		return web.JsonError(err)
+	}
+	cnd := params.NewPagedSqlCnd(c.Ctx, params.QueryFilter{ParamName: "ticketId"}).Desc("id")
+	list, paging := services.TicketEventLogService.FindPageByCnd(cnd)
+	return web.JsonData(&web.PageResult{Results: builders.BuildTicketEventLogList(list), Page: paging})
+}

internal/controllers/console/ticket_priority_config_controller.go

@@ -0,0 +1,102 @@
+package console
+
+import (
+	"cs-agent/internal/builders"
+	"cs-agent/internal/pkg/constants"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/pkg/enums"
+	"cs-agent/internal/services"
+	"strings"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/sqls"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type TicketPriorityConfigController struct{ Ctx iris.Context }
+
+func (c *TicketPriorityConfigController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketPriorityConfigView); err != nil {
+		return web.JsonError(err)
+	}
+	cnd := sqls.NewCnd().Asc("sort_no").Asc("id")
+	if status, ok := params.Get(c.Ctx, "status"); ok && strings.TrimSpace(status) != "" {
+		cnd.Eq("status", status)
+	} else {
+		cnd.Where("status <> ?", enums.StatusDeleted)
+	}
+	if name, ok := params.Get(c.Ctx, "name"); ok && strings.TrimSpace(name) != "" {
+		cnd.Where("name LIKE ?", "%"+strings.TrimSpace(name)+"%")
+	}
+	list := services.TicketPriorityConfigService.Find(cnd)
+	return web.JsonData(builders.BuildTicketPriorityConfigList(list))
+}
+
+func (c *TicketPriorityConfigController) GetList_all() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketPriorityConfigView); err != nil {
+		return web.JsonError(err)
+	}
+	list := services.TicketPriorityConfigService.Find(sqls.NewCnd().Eq("status", enums.StatusOk).Asc("sort_no").Asc("id"))
+	return web.JsonData(builders.BuildTicketPriorityConfigList(list))
+}
+
+func (c *TicketPriorityConfigController) PostCreate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketPriorityConfigCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.CreateTicketPriorityConfigRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.TicketPriorityConfigService.CreateTicketPriorityConfig(req, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildTicketPriorityConfig(item))
+}
+
+func (c *TicketPriorityConfigController) PostUpdate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketPriorityConfigUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.UpdateTicketPriorityConfigRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketPriorityConfigService.UpdateTicketPriorityConfig(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketPriorityConfigController) PostUpdate_sort() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketPriorityConfigUpdate); err != nil {
+		return web.JsonError(err)
+	}
+	var ids []int64
+	if err := c.Ctx.ReadJSON(&ids); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketPriorityConfigService.UpdateSort(ids); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketPriorityConfigController) PostDelete() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketPriorityConfigDelete)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.DeleteTicketPriorityConfigRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketPriorityConfigService.DeleteTicketPriorityConfig(req.ID, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}

internal/controllers/console/ticket_resolution_code_controller.go

@@ -0,0 +1,85 @@
+package console
+
+import (
+	"cs-agent/internal/builders"
+	"cs-agent/internal/pkg/constants"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/pkg/enums"
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/sqls"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type TicketResolutionCodeController struct{ Ctx iris.Context }
+
+func (c *TicketResolutionCodeController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketResolutionCodeView); err != nil {
+		return web.JsonError(err)
+	}
+	cnd := params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "status"},
+		params.QueryFilter{ParamName: "name", Op: params.Like},
+	).Asc("sort_no").Desc("id")
+	if _, ok := params.Get(c.Ctx, "status"); !ok {
+		cnd.Where("status <> ?", enums.StatusDeleted)
+	}
+	list, paging := services.TicketResolutionCodeService.FindPageByCnd(cnd)
+	return web.JsonData(&web.PageResult{Results: builders.BuildTicketResolutionCodeList(list), Page: paging})
+}
+
+func (c *TicketResolutionCodeController) GetList_all() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketResolutionCodeView); err != nil {
+		return web.JsonError(err)
+	}
+	list := services.TicketResolutionCodeService.Find(sqls.NewCnd().Eq("status", enums.StatusOk).Asc("sort_no").Desc("id"))
+	return web.JsonData(builders.BuildTicketResolutionCodeList(list))
+}
+
+func (c *TicketResolutionCodeController) PostCreate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketResolutionCodeCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.CreateTicketResolutionCodeRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	item, err := services.TicketResolutionCodeService.CreateTicketResolutionCode(req, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildTicketResolutionCode(item))
+}
+
+func (c *TicketResolutionCodeController) PostUpdate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketResolutionCodeUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.UpdateTicketResolutionCodeRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketResolutionCodeService.UpdateTicketResolutionCode(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *TicketResolutionCodeController) PostDelete() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionTicketResolutionCodeDelete)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	req := request.DeleteTicketResolutionCodeRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.TicketResolutionCodeService.DeleteTicketResolutionCode(req.ID, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}

internal/controllers/console/user_controller.go

@@ -0,0 +1,199 @@
+package console
+
+import (
+	"cs-agent/internal/builders"
+	"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/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type UserController struct {
+	Ctx iris.Context
+}
+
+func (c *UserController) AnyList() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionUserView); err != nil {
+		return web.JsonError(err)
+	}
+
+	cnd := params.NewPagedSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "status"},
+		params.QueryFilter{ParamName: "username", Op: params.Like},
+		params.QueryFilter{ParamName: "nickname", Op: params.Like},
+	).Desc("id")
+	cnd.Where("status <> ?", enums.StatusDeleted)
+	list, paging := services.UserService.FindPageByCnd(cnd)
+	results := builders.BuildUserList(list, builders.UserBuildOptions{
+		Roles:       true,
+		Permissions: false,
+	})
+	return web.JsonData(&web.PageResult{Results: results, Page: paging})
+}
+
+func (c *UserController) AnyList_all() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionUserView); err != nil {
+		return web.JsonError(err)
+	}
+
+	cnd := params.NewSqlCnd(c.Ctx,
+		params.QueryFilter{ParamName: "status"},
+		params.QueryFilter{ParamName: "username", Op: params.Like},
+		params.QueryFilter{ParamName: "nickname", Op: params.Like},
+	).Desc("id")
+	cnd.Where("status <> ?", enums.StatusDeleted)
+
+	list := services.UserService.Find(cnd)
+	results := builders.BuildUserList(list, builders.UserBuildOptions{
+		Roles:       true,
+		Permissions: false,
+	})
+	return web.JsonData(results)
+}
+
+func (c *UserController) GetBy(id int64) *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionUserView); err != nil {
+		return web.JsonError(err)
+	}
+
+	item := services.UserService.Get(id)
+	if item == nil {
+		return web.JsonErrorMsg("用户不存在")
+	}
+	return web.JsonData(builders.BuildUserResponse(item, builders.UserBuildOptions{
+		Roles:       true,
+		Permissions: true,
+	}))
+}
+
+func (c *UserController) PostCreate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionUserCreate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.CreateUserRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	user, generatedPassword, err := services.UserService.CreateUser(req, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(&response.CreateUserResultResponse{
+		User:     builders.BuildUserResponse(user, builders.UserBuildOptions{Roles: true, Permissions: true}),
+		Password: generatedPassword,
+	})
+}
+
+func (c *UserController) PostUpdate() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionUserUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.UpdateUserRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.UserService.UpdateUser(req, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *UserController) PostDelete() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionUserDelete)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.DeleteUserRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.UserService.DeleteUser(req.ID, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *UserController) PostUpdate_status() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionUserUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.UpdateUserStatusRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.UserService.UpdateStatus(req.ID, req.Status, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *UserController) PostReset_password() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionUserUpdate)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	var req struct {
+		UserID int64 `json:"userId"`
+	}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	password, err := services.UserService.ResetPassword(req.UserID, operator)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(map[string]any{
+		"password": password,
+	})
+}
+
+func (c *UserController) PostChange_password() *web.JsonResult {
+	principal := services.AuthService.GetAuthPrincipal(c.Ctx)
+	if principal == nil {
+		if _, err := services.AuthService.Authenticate(c.Ctx); err != nil {
+			return web.JsonError(err)
+		}
+		principal = services.AuthService.GetAuthPrincipal(c.Ctx)
+	}
+	if principal == nil {
+		return web.JsonErrorMsg("未登录或登录已过期")
+	}
+
+	req := request.ChangePasswordRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.UserService.ChangeOwnPassword(req.Password, principal); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *UserController) PostAssign_role() *web.JsonResult {
+	operator, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionUserAssignRole)
+	if err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.AssignRoleRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.UserService.AssignRoles(req.UserID, req.RoleIDs, operator); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}

internal/controllers/open/im_conversation_controller.go

@@ -0,0 +1,77 @@
+package open
+
+import (
+	"cs-agent/internal/builders"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/pkg/dto/response"
+	"cs-agent/internal/pkg/irisx"
+	"cs-agent/internal/services"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+)
+
+type ImConversationController struct {
+	Ctx iris.Context
+}
+
+func (c *ImConversationController) GetBy(id int64) *web.JsonResult {
+	if irisx.GetChannel(c.Ctx) == nil {
+		return web.JsonErrorMsg("接入渠道未初始化")
+	}
+	external := irisx.GetExternalInfo(c.Ctx)
+	if external == nil {
+		return web.JsonErrorMsg("外部身份未初始化")
+	}
+
+	item := services.ConversationService.Get(id)
+	if item == nil {
+		return web.JsonErrorMsg("会话不存在")
+	}
+	if !services.ConversationService.IsCustomerConversationOwner(item, *external) {
+		return web.JsonErrorMsg("无权访问该会话")
+	}
+
+	detail := response.ConversationDetailResponse{
+		ConversationResponse: builders.BuildConversation(item),
+		Participants:         builders.BuildParticipantResponses(id),
+	}
+	return web.JsonData(detail)
+}
+
+func (c *ImConversationController) PostCreate_or_match() *web.JsonResult {
+	channel := irisx.GetChannel(c.Ctx)
+	if channel == nil {
+		return web.JsonErrorMsg("接入渠道未初始化")
+	}
+	external := irisx.GetExternalInfo(c.Ctx)
+	if external == nil {
+		return web.JsonErrorMsg("外部身份未初始化")
+	}
+
+	item, err := services.ConversationService.Create(*external, channel.AIAgentID)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildConversation(item))
+}
+
+func (c *ImConversationController) PostClose() *web.JsonResult {
+	if irisx.GetChannel(c.Ctx) == nil {
+		return web.JsonErrorMsg("接入渠道未初始化")
+	}
+	external := irisx.GetExternalInfo(c.Ctx)
+	if external == nil {
+		return web.JsonErrorMsg("外部身份未初始化")
+	}
+
+	req := request.CloseConversationRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.ConversationService.CloseCustomerConversation(req.ConversationID, *external); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}

internal/controllers/open/im_message_controller.go

@@ -0,0 +1,173 @@
+package open
+
+import (
+	"cs-agent/internal/builders"
+	"cs-agent/internal/pkg/dto/request"
+	"cs-agent/internal/pkg/enums"
+	"cs-agent/internal/pkg/irisx"
+	"cs-agent/internal/services"
+	"strconv"
+	"strings"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+	"github.com/mlogclub/simple/web/params"
+	"github.com/spf13/cast"
+)
+
+type ImMessageController struct {
+	Ctx iris.Context
+}
+
+func (c *ImMessageController) AnyList() *web.JsonResult {
+	if irisx.GetChannel(c.Ctx) == nil {
+		return web.JsonErrorMsg("接入渠道未初始化")
+	}
+	external := irisx.GetExternalInfo(c.Ctx)
+	if external == nil {
+		return web.JsonErrorMsg("外部身份未初始化")
+	}
+
+	conversationID, _ := params.GetInt64(c.Ctx, "conversationId")
+	if conversationID <= 0 {
+		return web.JsonErrorMsg("conversationId不能为空")
+	}
+	conversation := services.ConversationService.Get(conversationID)
+	if conversation == nil {
+		return web.JsonErrorMsg("会话不存在")
+	}
+	if !services.ConversationService.IsCustomerConversationOwner(conversation, *external) {
+		return web.JsonErrorMsg("无权访问该会话")
+	}
+
+	var (
+		senderType, _  = params.Get(c.Ctx, "senderType")
+		messageType, _ = params.Get(c.Ctx, "messageType")
+		cursor, _      = params.GetInt64(c.Ctx, "cursor")
+		limit, _       = params.GetInt(c.Ctx, "limit")
+	)
+	list, nextCursor, hasMore := services.MessageService.FindByConversationIDCursor(
+		conversationID, cursor, limit, senderType, messageType,
+	)
+	results := builders.BuildMessages(list)
+	return web.JsonCursorData(results, cast.ToString(nextCursor), hasMore)
+}
+
+func (c *ImMessageController) PostSend() *web.JsonResult {
+	if irisx.GetChannel(c.Ctx) == nil {
+		return web.JsonErrorMsg("接入渠道未初始化")
+	}
+	external := irisx.GetExternalInfo(c.Ctx)
+	if external == nil {
+		return web.JsonErrorMsg("外部身份未初始化")
+	}
+
+	req := request.SendConversationMessageRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+
+	item, err := services.MessageService.SendCustomerMessage(req.ConversationID, req.ClientMsgID, req.MessageType, req.Content, req.Payload, *external)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildMessage(item))
+}
+
+func (c *ImMessageController) PostRead() *web.JsonResult {
+	if irisx.GetChannel(c.Ctx) == nil {
+		return web.JsonErrorMsg("接入渠道未初始化")
+	}
+	external := irisx.GetExternalInfo(c.Ctx)
+	if external == nil {
+		return web.JsonErrorMsg("外部身份未初始化")
+	}
+
+	req := request.ReadConversationRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	if err := services.ConversationService.MarkCustomerConversationReadToMessage(req.ConversationID, req.MessageID, external); err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonSuccess()
+}
+
+func (c *ImMessageController) PostUpload_image() *web.JsonResult {
+	if irisx.GetChannel(c.Ctx) == nil {
+		return web.JsonErrorMsg("接入渠道未初始化")
+	}
+	external := irisx.GetExternalInfo(c.Ctx)
+	if external == nil {
+		return web.JsonErrorMsg("外部身份未初始化")
+	}
+
+	rawConv := strings.TrimSpace(c.Ctx.FormValue("conversationId"))
+	if rawConv == "" {
+		return web.JsonErrorMsg("conversationId不能为空")
+	}
+	conversationID, err := strconv.ParseInt(rawConv, 10, 64)
+	if err != nil || conversationID <= 0 {
+		return web.JsonErrorMsg("conversationId不能为空")
+	}
+	conversation := services.ConversationService.Get(conversationID)
+	if conversation == nil {
+		return web.JsonErrorMsg("会话不存在")
+	}
+	if !services.ConversationService.IsCustomerConversationOwner(conversation, *external) {
+		return web.JsonErrorMsg("无权访问该会话")
+	}
+	if _, err := services.MessageService.ValidateConversationSender(conversationID, enums.IMSenderTypeCustomer, nil, external); err != nil {
+		return web.JsonError(err)
+	}
+
+	f, header, err := c.Ctx.FormFile("file")
+	if err != nil {
+		return web.JsonErrorMsg("请选择上传图片")
+	}
+	_ = f.Close()
+
+	if !strings.HasPrefix(strings.ToLower(header.Header.Get("Content-Type")), "image/") {
+		return web.JsonErrorMsg("仅支持上传图片文件")
+	}
+
+	item, err := services.AssetService.UploadFile(header, "images", nil)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildAsset(item))
+}
+
+func (c *ImMessageController) PostUpload_attachment() *web.JsonResult {
+	if irisx.GetChannel(c.Ctx) == nil {
+		return web.JsonErrorMsg("接入渠道未初始化")
+	}
+	external := irisx.GetExternalInfo(c.Ctx)
+	if external == nil {
+		return web.JsonErrorMsg("外部身份未初始化")
+	}
+
+	rawConv := strings.TrimSpace(c.Ctx.FormValue("conversationId"))
+	if rawConv == "" {
+		return web.JsonErrorMsg("conversationId不能为空")
+	}
+	conversationID, err := strconv.ParseInt(rawConv, 10, 64)
+	if err != nil || conversationID <= 0 {
+		return web.JsonErrorMsg("conversationId不能为空")
+	}
+	if _, err := services.MessageService.ValidateConversationSender(conversationID, enums.IMSenderTypeCustomer, nil, external); err != nil {
+		return web.JsonError(err)
+	}
+
+	f, header, err := c.Ctx.FormFile("file")
+	if err != nil {
+		return web.JsonErrorMsg("请选择上传附件")
+	}
+	_ = f.Close()
+
+	item, err := services.AssetService.UploadFile(header, "attachments", nil)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(builders.BuildAsset(item))
+}

internal/controllers/open/im_widget_controller.go

@@ -0,0 +1,25 @@
+package open
+
+import (
+	"cs-agent/internal/pkg/dto/response"
+	"cs-agent/internal/pkg/irisx"
+
+	"github.com/kataras/iris/v12"
+	"github.com/mlogclub/simple/web"
+)
+
+type ImWidgetController struct {
+	Ctx iris.Context
+}
+
+func (c *ImWidgetController) AnyConfig() *web.JsonResult {
+	channel := irisx.GetChannel(c.Ctx)
+	if channel == nil {
+		return web.JsonErrorMsg("接入渠道未初始化")
+	}
+
+	ret := response.WidgetConfigResponse{
+		ChannelID: channel.ChannelID,
+	}
+	return web.JsonData(ret)
+}

internal/controllers/third/wechat_controller.go

@@ -0,0 +1,66 @@
+package third
+
+import (
+	"cs-agent/internal/wxwork"
+	"net/http"
+
+	"github.com/kataras/iris/v12"
+	"github.com/silenceper/wechat/v2/work/kf"
+)
+
+type WechatController struct {
+	Ctx iris.Context
+}
+
+// GetCallback GET请求用于校验回调是否配置正确
+func (c *WechatController) GetCallback() {
+	cli, err := wxwork.GetWorkCli().GetKF()
+	if err != nil {
+		c.Ctx.StopWithError(http.StatusInternalServerError, err)
+		return
+	}
+	options := kf.SignatureOptions{}
+	if err := c.Ctx.ReadForm(&options); err != nil {
+		c.Ctx.StopWithError(http.StatusUnauthorized, err)
+		return
+	}
+	// 调用VerifyURL方法校验当前请求，如果合法则把解密后的内容作为响应返回给微信服务器
+	echo, err := cli.VerifyURL(options)
+	if err == nil {
+		c.Ctx.WriteString(echo)
+	} else {
+		c.Ctx.StopWithError(http.StatusUnauthorized, err)
+	}
+}
+
+// PostCallback POST请求用于接收回调
+func (c *WechatController) PostCallback() {
+	cli, err := wxwork.GetWorkCli().GetKF()
+	if err != nil {
+		c.Ctx.StopWithError(http.StatusInternalServerError, err)
+		return
+	}
+	var (
+		message kf.CallbackMessage
+		body    []byte
+	)
+	// 读取原始消息内容
+	body, err = c.Ctx.GetBody()
+	if err != nil {
+		c.Ctx.StopWithError(http.StatusInternalServerError, err)
+		return
+	}
+	// 解析原始数据
+	message, err = cli.GetCallbackMessage(body)
+	if err != nil {
+		c.Ctx.StopWithError(http.StatusInternalServerError, err)
+		return
+	}
+
+	if err := wxwork.ConsumeCallback(message); err != nil {
+		c.Ctx.StopWithError(http.StatusInternalServerError, err)
+		return
+	}
+
+	c.Ctx.WriteString("ok")
+}