Refactor API endpoints to use /api/dashboard instead of /api/console

- Updated all relevant API functions in agent.ts, company.ts, customer-contact.ts, customer.ts, dashboard.ts, ticket-config.ts, and ticket.ts to point to the new /api/dashboard paths.
- Ensured that all request methods and payload structures remain unchanged to maintain existing functionality.

internal/controllers/dashboard/agent_controller.go

@@ -0,0 +1,101 @@
+package dashboard
+
+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/dashboard/agent_run_log_controller.go

@@ -0,0 +1,60 @@
+package dashboard
+
+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: "graphToolCode"},
+		params.QueryFilter{ParamName: "interruptType"},
+		params.QueryFilter{ParamName: "resumeSource"},
+		params.QueryFilter{ParamName: "finalStatus"},
+		params.QueryFilter{ParamName: "handoffReason", Op: params.Like},
+		params.QueryFilter{ParamName: "finalAction"},
+		params.QueryFilter{ParamName: "userMessage", Op: params.Like},
+	).Desc("id")
+	if hitlStatus, _ := params.Get(c.Ctx, "hitlStatus"); hitlStatus != "" && hitlStatus != "all" {
+		cnd = services.AgentRunLogService.ApplyHITLStatusFilter(cnd, hitlStatus)
+	}
+	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/dashboard/agent_team_controller.go

@@ -0,0 +1,124 @@
+package dashboard
+
+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/dashboard/agent_team_schedule_controller.go

@@ -0,0 +1,103 @@
+package dashboard
+
+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/dashboard/ai_agent_controller.go

@@ -0,0 +1,241 @@
+package dashboard
+
+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/toolx"
+	"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(item.ServiceMode),
+		SystemPrompt:        item.SystemPrompt,
+		WelcomeMessage:      item.WelcomeMessage,
+		ReplyTimeoutSeconds: item.ReplyTimeoutSeconds,
+		HandoffMode:         item.HandoffMode,
+		HandoffModeName:     enums.GetAIAgentHandoffModeLabel(item.HandoffMode),
+		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),
+		GraphTools:          make([]string, 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 {
+				toolCode := strings.TrimSpace(tool.ToolCode)
+				if toolCode == "" {
+					toolCode = toolx.BuildMCPToolCode(tool.ServerCode, tool.ToolName)
+				}
+				toolCode = toolx.NormalizeToolCodeAlias(toolCode)
+				if toolx.IsAutoInjectedToolCode(toolCode) {
+					continue
+				}
+				if toolx.IsAgentDirectGraphToolCode(toolCode) {
+					ret.GraphTools = appendGraphToolCodeIfMissing(ret.GraphTools, toolCode)
+					continue
+				}
+				serverCode := strings.TrimSpace(tool.ServerCode)
+				toolName := strings.TrimSpace(tool.ToolName)
+				if registeredServerCode, registeredToolName, ok := toolx.GetRegisteredToolIdentity(toolCode); ok {
+					serverCode = registeredServerCode
+					toolName = registeredToolName
+				} else if parsedServerCode, parsedToolName := toolx.SplitMCPToolCode(toolCode); parsedServerCode != "" && parsedToolName != "" {
+					serverCode = parsedServerCode
+					toolName = parsedToolName
+				}
+				title := strings.TrimSpace(tool.Title)
+				if title == "" {
+					if registeredTitle := toolx.GetRegisteredToolTitle(toolCode); registeredTitle != "" {
+						title = registeredTitle
+					}
+				}
+				description := strings.TrimSpace(tool.Description)
+				if description == "" {
+					if registeredDescription := toolx.GetRegisteredToolDescription(toolCode); registeredDescription != "" {
+						description = registeredDescription
+					}
+				}
+				ret.DirectTools = append(ret.DirectTools, response.AIAgentMCPToolResponse{
+					ToolCode:    toolCode,
+					ServerCode:  serverCode,
+					ToolName:    toolName,
+					Title:       title,
+					Description: description,
+					Arguments:   tool.Arguments,
+				})
+			}
+		}
+	}
+	if raw := strings.TrimSpace(item.AllowedGraphTools); raw != "" {
+		var graphTools []string
+		if err := json.Unmarshal([]byte(raw), &graphTools); err == nil {
+			for _, toolCode := range graphTools {
+				toolCode = toolx.NormalizeToolCodeAlias(strings.TrimSpace(toolCode))
+				if !toolx.IsAgentDirectGraphToolCode(toolCode) {
+					continue
+				}
+				ret.GraphTools = appendGraphToolCodeIfMissing(ret.GraphTools, toolCode)
+			}
+		}
+	}
+	return ret
+}
+
+func appendGraphToolCodeIfMissing(items []string, toolCode string) []string {
+	toolCode = strings.TrimSpace(toolCode)
+	if toolCode == "" {
+		return items
+	}
+	for _, item := range items {
+		if strings.TrimSpace(item) == toolCode {
+			return items
+		}
+	}
+	return append(items, toolCode)
+}

internal/controllers/dashboard/ai_config_controller.go

@@ -0,0 +1,143 @@
+package dashboard
+
+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/dashboard/asset_controller.go

@@ -0,0 +1,92 @@
+package dashboard
+
+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/dashboard/channel_controller.go

@@ -0,0 +1,118 @@
+package dashboard
+
+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/dashboard/company_controller.go

@@ -0,0 +1,113 @@
+package dashboard
+
+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/dashboard/conversation_controller.go

@@ -0,0 +1,365 @@
+package dashboard
+
+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/dashboard/customer_contact_controller.go

@@ -0,0 +1,76 @@
+package dashboard
+
+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/dashboard/customer_controller.go

@@ -0,0 +1,129 @@
+package dashboard
+
+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/dashboard/dashboard_controller.go

@@ -0,0 +1,18 @@
+package dashboard
+
+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/dashboard/knowledge_base_controller.go

@@ -0,0 +1,164 @@
+package dashboard
+
+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/dashboard/knowledge_document_controller.go

@@ -0,0 +1,111 @@
+package dashboard
+
+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/dashboard/knowledge_faq_controller.go

@@ -0,0 +1,94 @@
+package dashboard
+
+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/dashboard/knowledge_retrieve_controller.go

@@ -0,0 +1,85 @@
+package dashboard
+
+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/dashboard/knowledge_retrieve_log_controller.go

@@ -0,0 +1,77 @@
+package dashboard
+
+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/dashboard/mcp_controller.go

@@ -0,0 +1,95 @@
+package dashboard
+
+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) AnyCatalog() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionMCPView); err != nil {
+		return web.JsonError(err)
+	}
+	items, err := services.ToolCatalogService.ListMCPTools(context.Background())
+	if err != nil {
+		return web.JsonError(err)
+	}
+	ret := make([]response.MCPToolCatalogResponse, 0, len(items))
+	for _, item := range items {
+		ret = append(ret, response.MCPToolCatalogResponse{
+			ToolCode:     item.ToolCode,
+			ServerCode:   item.ServerCode,
+			ToolName:     item.ToolName,
+			SourceType:   item.SourceType,
+			AutoInjected: item.AutoInjected,
+			Title:        item.Title,
+			Description:  item.Description,
+			InputSchema:  item.InputSchema,
+			OutputSchema: item.OutputSchema,
+		})
+	}
+	return web.JsonData(ret)
+}
+
+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/dashboard/permission_controller.go

@@ -0,0 +1,71 @@
+package dashboard
+
+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/dashboard/quick_reply_controller.go

@@ -0,0 +1,118 @@
+package dashboard
+
+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/dashboard/role_controller.go

@@ -0,0 +1,187 @@
+package dashboard
+
+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/dashboard/session_controller.go

@@ -0,0 +1,83 @@
+package dashboard
+
+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/dashboard/skill_definition_controller.go

@@ -0,0 +1,189 @@
+package dashboard
+
+import (
+	"context"
+	"time"
+
+	"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 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},
+	).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"},
+	).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)
+	}
+	item, err := services.SkillDefinitionService.CreateSkillDefinition(req, operator)
+	if 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 err := services.SkillDefinitionService.UpdateSkillDefinition(req, operator); 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) 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 (c *SkillDefinitionController) PostDebug_resume() *web.JsonResult {
+	if _, err := services.AuthService.RequirePermission(c.Ctx, constants.PermissionSkillDefinitionView); err != nil {
+		return web.JsonError(err)
+	}
+
+	req := request.SkillDebugResumeRequest{}
+	if err := params.ReadJSON(c.Ctx, &req); err != nil {
+		return web.JsonError(err)
+	}
+	resp, err := services.SkillRuntimeService.DebugResume(context.Background(), req)
+	if err != nil {
+		return web.JsonError(err)
+	}
+	return web.JsonData(resp)
+}

internal/controllers/dashboard/tag_controller.go

@@ -0,0 +1,127 @@
+package dashboard
+
+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/dashboard/ticket_controller.go

@@ -0,0 +1,501 @@
+package dashboard
+
+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/dashboard/ticket_priority_config_controller.go

@@ -0,0 +1,102 @@
+package dashboard
+
+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/dashboard/ticket_resolution_code_controller.go

@@ -0,0 +1,85 @@
+package dashboard
+
+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/dashboard/user_controller.go

@@ -0,0 +1,199 @@
+package dashboard
+
+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()
+}