aice/controllers/admin/BaseController.go

package admin

import (
	"strconv"
	"time"

	beego "github.com/beego/beego/v2/server/web"
	"github.com/dgrijalva/jwt-go"
)

// JWT配置
var (
	JWTSecret   = []byte("your-secret-key") // 生产环境应该使用更复杂的密钥
	TokenExpire = 7200                      // Token有效期，单位秒（2小时）
)

// 用户信息结构
type UserInfo struct {
	Id       int    `json:"id"`
	Username string `json:"username"`
	Role     string `json:"role"`
	// 其他用户信息字段...
}

// JWT Claims结构
type Claims struct {
	UserInfo UserInfo `json:"user_info"`
	jwt.StandardClaims
}

// BaseController 基础控制器，提供JWT鉴权和权限控制
type BaseController struct {
	beego.Controller
	UserInfo UserInfo // 当前登录用户信息
	IsLogin  bool     // 是否已登录
}

// 生成Token
func GenerateToken(userInfo UserInfo) (string, error) {
	expireTime := time.Now().Add(time.Duration(TokenExpire) * time.Second)
	claims := &Claims{
		UserInfo: userInfo,
		StandardClaims: jwt.StandardClaims{
			ExpiresAt: expireTime.Unix(),
			IssuedAt:  time.Now().Unix(),
		},
	}

	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	return token.SignedString(JWTSecret)
}

// 解析Token
func ParseToken(tokenString string) (*Claims, error) {
	token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
		return JWTSecret, nil
	})

	if err != nil {
		return nil, err
	}

	if claims, ok := token.Claims.(*Claims); ok && token.Valid {
		return claims, nil
	}

	return nil, err
}

// 验证Token中间件
func (c *BaseController) VerifyToken() {
	tokenString := c.Ctx.Input.Header("Authorization")
	if tokenString == "" {
		c.Error("Authorization token required", 401)
		return
	}

	claims, err := ParseToken(tokenString)
	if err != nil {
		c.Error("Invalid token: "+err.Error(), 401)
		return
	}

	// 检查Token是否过期
	if time.Now().Unix() > claims.ExpiresAt {
		c.Error("Token expired", 401)
		return
	}

	// 设置用户信息
	c.UserInfo = claims.UserInfo
	c.IsLogin = true
}

// 权限检查函数类型
type PermissionCheckFunc func(userInfo UserInfo, permission string) bool

// 默认权限检查函数
func DefaultPermissionCheck(userInfo UserInfo, permission string) bool {
	// 这里实现具体的权限逻辑
	// 例如：检查用户角色是否有所需权限
	// 简单示例：admin角色有所有权限
	if userInfo.Role == "admin" {
		return true
	}
	// 可以根据具体权限字符串检查
	// 实际项目中应该查询数据库或缓存中的权限配置
	return false
}

// 检查权限中间件
func (c *BaseController) CheckPermission(permission string, checkFunc ...PermissionCheckFunc) {
	if !c.IsLogin {
		c.Error("Permission denied, user not logged in", 403)
		return
	}

	var check PermissionCheckFunc
	if len(checkFunc) > 0 {
		check = checkFunc[0]
	} else {
		check = DefaultPermissionCheck
	}

	if !check(c.UserInfo, permission) {
		c.Error("Permission denied for user: "+c.UserInfo.Username, 403)
		return
	}
}

// 返回JSON响应
func (c *BaseController) JSONResponse(data interface{}, errCode ...int) {
	code := 200
	if len(errCode) > 0 {
		code = errCode[0]
	}

	response := map[string]interface{}{
		"code": code,
		"data": data,
		"msg":  getMessageByCode(code),
	}

	c.Data["json"] = response
	c.ServeJSON()
}

// 成功响应
func (c *BaseController) Success(data interface{}, msg ...string) {
	message := "success"
	if len(msg) > 0 {
		message = msg[0]
	}
	response := map[string]interface{}{
		"code": 200,
		"data": data,
		"msg":  message,
	}
	c.Data["json"] = response
	c.ServeJSON()
}

// 失败响应
func (c *BaseController) Error(msg string, code ...int) {
	errCode := 400
	if len(code) > 0 {
		errCode = code[0]
	}
	response := map[string]interface{}{
		"code": errCode,
		"data": nil,
		"msg":  msg,
	}
	c.Data["json"] = response
	c.ServeJSON()
}

// 获取分页参数
func (c *BaseController) GetPageParams() (page, pageSize int) {
	page, _ = strconv.Atoi(c.Ctx.Input.Query("page"))
	if page < 1 {
		page = 1
	}
	pageSize, _ = strconv.Atoi(c.Ctx.Input.Query("pageSize"))
	if pageSize < 1 {
		pageSize = 20 // 默认每页20条
	}
	return page, pageSize
}

// Prepare 在执行任何HTTP方法之前调用
func (c *BaseController) Prepare() {
	// 自动验证Token（除了登录接口）
	if c.Ctx.Input.URL() != "/admin/login" {
		c.VerifyToken()
	}
}

// getMessageByCode 根据状态码获取消息
func getMessageByCode(code int) string {
	messages := map[int]string{
		200: "success",
		400: "bad request",
		401: "unauthorized",
		403: "forbidden",
		404: "not found",
		500: "internal server error",
	}
	if msg, ok := messages[code]; ok {
		return msg
	}
	return "unknown error"
}