smart-customer-service/backend/internal/router/router.go

package router

import (
	"time"

	"github.com/gin-gonic/gin"
	"smart-customer-service/config"
	"smart-customer-service/internal/handlers"
	"smart-customer-service/internal/middleware"
)

type Router struct {
	cfg      *config.Config
	handlers *handlers.Handlers
}

func New(cfg *config.Config) *Router {
	return &Router{
		cfg:      cfg,
		handlers: handlers.New(cfg),
	}
}

// SetupRoutes 配置所有路由
func (r *Router) SetupRoutes() *gin.Engine {
	// 设置 Gin 模式
	if r.cfg.Server.Mode == "release" {
		gin.SetMode(gin.ReleaseMode)
	}

	router := gin.Default()

	// 全局中间件
	router.Use(middleware.CORS())
	router.Use(middleware.Logger())
	router.Use(middleware.Recovery())

	// ============ API 路由 ============
	api := router.Group("/api")
	{
		// === 公共路由（无需认证） ===
		public := api.Group("/v1")
		{
			// 认证
			public.POST("/auth/login", r.handlers.Auth.Login)
			public.POST("/auth/register", r.handlers.Auth.Register)
			public.POST("/auth/refresh", r.handlers.Auth.RefreshToken)

			// 租户注册
			public.POST("/tenants/register", r.handlers.Tenant.Register)
		}

		// === 需要认证的路由 ===
		protected := api.Group("/v1")
		protected.Use(middleware.Auth(r.cfg.JWT.Secret))
		{
			// 租户管理
			r.setupTenantRoutes(protected)

			// 用户管理
			r.setupUserRoutes(protected)

			// 角色管理
			r.setupRoleRoutes(protected)

			// 资源管理
			r.setupResourceRoutes(protected)

			// 会话管理
			r.setupConversationRoutes(protected)

			// 工单管理
			r.setupTicketRoutes(protected)

			// 知识库管理
			r.setupKnowledgeRoutes(protected)
		}

		// === 管理员路由 ===
		admin := api.Group("/admin")
		admin.Use(middleware.Auth(r.cfg.JWT.Secret))
		admin.Use(middleware.AdminOnly())
		{
			// 全局租户管理
			admin.GET("/tenants", r.handlers.Tenant.ListAll)
			admin.PUT("/tenants/:id/status", r.handlers.Tenant.UpdateStatus)

			// 全局用户管理
			admin.GET("/users", r.handlers.User.ListAll)

			// 统计数据
			admin.GET("/stats", r.handlers.Admin.GetStats)
			admin.GET("/stats/tenants", r.handlers.Admin.GetTenantStats)
			admin.GET("/stats/users", r.handlers.Admin.GetUserStats)

			// 系统配置
			admin.GET("/config", r.handlers.Admin.GetConfig)
			admin.PUT("/config", r.handlers.Admin.UpdateConfig)
		}
	}

	// === 健康检查 ===
	router.GET("/health", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"status": "ok",
			"time":   time.Now().Unix(),
		})
	})

	// === 版本信息 ===
	router.GET("/version", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"version": "1.0.0",
			"build":   "development",
		})
	})

	return router
}

// setupTenantRoutes 配置租户路由
func (r *Router) setupTenantRoutes(g *gin.RouterGroup) {
	tenants := g.Group("/tenants")
	{
		tenants.GET("", r.handlers.Tenant.List)                 // 列表
		tenants.GET("/:id", r.handlers.Tenant.Get)              // 详情
		tenants.PUT("/:id", r.handlers.Tenant.Update)           // 更新
		tenants.DELETE("/:id", r.handlers.Tenant.Delete)        // 删除
		tenants.POST("/:id/activate", r.handlers.Tenant.Activate)  // 激活
		tenants.POST("/:id/suspend", r.handlers.Tenant.Suspend)    // 暂停
		tenants.GET("/:id/stats", r.handlers.Tenant.GetStats)     // 统计
	}
}

// setupUserRoutes 配置用户路由
func (r *Router) setupUserRoutes(g *gin.RouterGroup) {
	users := g.Group("/users")
	{
		users.GET("", r.handlers.User.List)                        // 列表
		users.POST("", r.handlers.User.Create)                     // 创建
		users.GET("/:id", r.handlers.User.Get)                     // 详情
		users.PUT("/:id", r.handlers.User.Update)                  // 更新
		users.DELETE("/:id", r.handlers.User.Delete)               // 删除
		users.PUT("/:id/change-password", r.handlers.User.ChangePassword) // 修改密码
		users.POST("/:id/assign-roles", r.handlers.User.AssignRoles)  // 分配角色
		
		// 个人资料
		users.GET("/profile", r.handlers.User.GetProfile)
		users.PUT("/profile", r.handlers.User.UpdateProfile)
	}
}

// setupRoleRoutes 配置角色路由
func (r *Router) setupRoleRoutes(g *gin.RouterGroup) {
	roles := g.Group("/roles")
	{
		roles.GET("", r.handlers.Role.List)                          // 列表
		roles.POST("", r.handlers.Role.Create)                       // 创建
		roles.GET("/:id", r.handlers.Role.Get)                       // 详情
		roles.PUT("/:id", r.handlers.Role.Update)                    // 更新
		roles.DELETE("/:id", r.handlers.Role.Delete)                 // 删除
		roles.POST("/:id/assign-resources", r.handlers.Role.AssignResources) // 分配资源
		roles.GET("/:id/permissions", r.handlers.Role.GetPermissions)      // 获取权限
	}
}

// setupResourceRoutes 配置资源路由
func (r *Router) setupResourceRoutes(g *gin.RouterGroup) {
	resources := g.Group("/resources")
	{
		resources.GET("", r.handlers.Resource.List)                     // 列表
		resources.POST("", r.handlers.Resource.Create)                  // 创建
		resources.GET("/:id", r.handlers.Resource.Get)                  // 详情
		resources.PUT("/:id", r.handlers.Resource.Update)               // 更新
		resources.DELETE("/:id", r.handlers.Resource.Delete)            // 删除
		resources.GET("/tree", r.handlers.Resource.GetTree)            // 资源树
		resources.GET("/code/:code", r.handlers.Resource.GetResourceByCode) // 通过代码查询
		resources.POST("/check-permission", r.handlers.Resource.CheckPermission) // 权限检查
	}
}

// setupConversationRoutes 配置会话路由
func (r *Router) setupConversationRoutes(g *gin.RouterGroup) {
	g.GET("/conversations", r.handlers.Conversation.List)
	g.POST("/conversations", r.handlers.Conversation.Create)
	g.GET("/conversations/:id", r.handlers.Conversation.Get)
	g.GET("/conversations/:id/messages", r.handlers.Conversation.GetMessages)
}

// setupTicketRoutes 配置工单路由
func (r *Router) setupTicketRoutes(g *gin.RouterGroup) {
	g.GET("/tickets", r.handlers.Ticket.List)
	g.POST("/tickets", r.handlers.Ticket.Create)
	g.GET("/tickets/:id", r.handlers.Ticket.Get)
	g.PUT("/tickets/:id", r.handlers.Ticket.Update)
}

// setupKnowledgeRoutes 配置知识库路由
func (r *Router) setupKnowledgeRoutes(g *gin.RouterGroup) {
	g.GET("/knowledge", r.handlers.Knowledge.List)
	g.POST("/knowledge", r.handlers.Knowledge.Create)
	g.PUT("/knowledge/:id", r.handlers.Knowledge.Update)
	g.DELETE("/knowledge/:id", r.handlers.Knowledge.Delete)
}