gin-vue-admin-2

思考并回答以下问题：

router

router/enter.go

package router

import (
    "github.com/flipped-aurora/gin-vue-admin/server/router/example"
    "github.com/flipped-aurora/gin-vue-admin/server/router/system"
)

type RouterGroup struct {
    System  system.RouterGroup
    Example example.RouterGroup
}

var RouterGroupApp = new(RouterGroup)

router/system/enter.go

package system

type RouterGroup struct {
    ApiRouter
    JwtRouter
    SysRouter
    BaseRouter
    InitRouter
    MenuRouter
    UserRouter
    CasbinRouter
    AutoCodeRouter
    AuthorityRouter
    DictionaryRouter
    OperationRecordRouter
    DictionaryDetailRouter
    AuthorityBtnRouter
    ChatGptRouter
}

router/system/sys_user.go

package system

import (
    v1 "github.com/flipped-aurora/gin-vue-admin/server/api/v1"
    "github.com/flipped-aurora/gin-vue-admin/server/middleware"
    "github.com/gin-gonic/gin"
)

type UserRouter struct{}

func (s *UserRouter) InitUserRouter(Router *gin.RouterGroup) {
    userRouter := Router.Group("user").Use(middleware.OperationRecord())
    userRouterWithoutRecord := Router.Group("user")
    baseApi := v1.ApiGroupApp.SystemApiGroup.BaseApi
    {
        userRouter.POST("admin_register", baseApi.Register)               // 管理员注册账号
        userRouter.POST("changePassword", baseApi.ChangePassword)         // 用户修改密码
        userRouter.POST("setUserAuthority", baseApi.SetUserAuthority)     // 设置用户权限
        userRouter.DELETE("deleteUser", baseApi.DeleteUser)               // 删除用户
        userRouter.PUT("setUserInfo", baseApi.SetUserInfo)                // 设置用户信息
        userRouter.PUT("setSelfInfo", baseApi.SetSelfInfo)                // 设置自身信息
        userRouter.POST("setUserAuthorities", baseApi.SetUserAuthorities) // 设置用户权限组
        userRouter.POST("resetPassword", baseApi.ResetPassword)           // 设置用户权限组
    }
    {
        userRouterWithoutRecord.POST("getUserList", baseApi.GetUserList) // 分页获取用户列表
        userRouterWithoutRecord.GET("getUserInfo", baseApi.GetUserInfo)  // 获取自身信息
    }
}

api/v1

api/v1/enter.go

package v1

import (
    "github.com/flipped-aurora/gin-vue-admin/server/api/v1/example"
    "github.com/flipped-aurora/gin-vue-admin/server/api/v1/system"
)

type ApiGroup struct {
    SystemApiGroup  system.ApiGroup
    ExampleApiGroup example.ApiGroup
}

var ApiGroupApp = new(ApiGroup)

api/v1/system/enter.go

package system

import "github.com/flipped-aurora/gin-vue-admin/server/service"

type ApiGroup struct {
    DBApi
    JwtApi
    BaseApi
    SystemApi
    CasbinApi
    AutoCodeApi
    SystemApiApi
    AuthorityApi
    DictionaryApi
    AuthorityMenuApi
    OperationRecordApi
    AutoCodeHistoryApi
    DictionaryDetailApi
    AuthorityBtnApi
    ChatGptApi
}

var (
    apiService              = service.ServiceGroupApp.SystemServiceGroup.ApiService
    jwtService              = service.ServiceGroupApp.SystemServiceGroup.JwtService
    menuService             = service.ServiceGroupApp.SystemServiceGroup.MenuService
    userService             = service.ServiceGroupApp.SystemServiceGroup.UserService
    initDBService           = service.ServiceGroupApp.SystemServiceGroup.InitDBService
    casbinService           = service.ServiceGroupApp.SystemServiceGroup.CasbinService
    autoCodeService         = service.ServiceGroupApp.SystemServiceGroup.AutoCodeService
    baseMenuService         = service.ServiceGroupApp.SystemServiceGroup.BaseMenuService
    authorityService        = service.ServiceGroupApp.SystemServiceGroup.AuthorityService
    dictionaryService       = service.ServiceGroupApp.SystemServiceGroup.DictionaryService
    systemConfigService     = service.ServiceGroupApp.SystemServiceGroup.SystemConfigService
    operationRecordService  = service.ServiceGroupApp.SystemServiceGroup.OperationRecordService
    autoCodeHistoryService  = service.ServiceGroupApp.SystemServiceGroup.AutoCodeHistoryService
    dictionaryDetailService = service.ServiceGroupApp.SystemServiceGroup.DictionaryDetailService
    authorityBtnService     = service.ServiceGroupApp.SystemServiceGroup.AuthorityBtnService
    chatGptService          = service.ServiceGroupApp.SystemServiceGroup.ChatGptService
)

api/v1/system/sys_user.go

package system

import (
    "strconv"
    "time"

    "github.com/flipped-aurora/gin-vue-admin/server/global"
    "github.com/flipped-aurora/gin-vue-admin/server/model/common/request"
    "github.com/flipped-aurora/gin-vue-admin/server/model/common/response"
    "github.com/flipped-aurora/gin-vue-admin/server/model/system"
    systemReq "github.com/flipped-aurora/gin-vue-admin/server/model/system/request"
    systemRes "github.com/flipped-aurora/gin-vue-admin/server/model/system/response"
    "github.com/flipped-aurora/gin-vue-admin/server/utils"

    "github.com/gin-gonic/gin"
    "github.com/go-redis/redis/v8"
    "go.uber.org/zap"
)

// Login
// @Tags     Base
// @Summary  用户登录
// @Produce   application/json
// @Param    data  body      systemReq.Login                                             true  "用户名, 密码, 验证码"
// @Success  200   {object}  response.Response{data=systemRes.LoginResponse,msg=string}  "返回包括用户信息,token,过期时间"
// @Router   /base/login [post]
func (b *BaseApi) Login(c *gin.Context) {
    var l systemReq.Login
    err := c.ShouldBindJSON(&l)
    key := c.ClientIP()

    if err != nil {
        response.FailWithMessage(err.Error(), c)
        return
    }
    err = utils.Verify(l, utils.LoginVerify)
    if err != nil {
        response.FailWithMessage(err.Error(), c)
        return
    }

    // 判断验证码是否开启
    openCaptcha := global.GVA_CONFIG.Captcha.OpenCaptcha               // 是否开启防爆次数
    openCaptchaTimeOut := global.GVA_CONFIG.Captcha.OpenCaptchaTimeOut // 缓存超时时间
    v, ok := global.BlackCache.Get(key)
    if !ok {
        global.BlackCache.Set(key, 1, time.Second*time.Duration(openCaptchaTimeOut))
    }

    var oc bool = openCaptcha == 0 || openCaptcha < interfaceToInt(v)

    if !oc || store.Verify(l.CaptchaId, l.Captcha, true) {
        u := &system.SysUser{Username: l.Username, Password: l.Password}
        user, err := userService.Login(u)
        if err != nil {
            global.GVA_LOG.Error("登陆失败! 用户名不存在或者密码错误!", zap.Error(err))
            // 验证码次数+1
            global.BlackCache.Increment(key, 1)
            response.FailWithMessage("用户名不存在或者密码错误", c)
            return
        }
        if user.Enable != 1 {
            global.GVA_LOG.Error("登陆失败! 用户被禁止登录!")
            // 验证码次数+1
            global.BlackCache.Increment(key, 1)
            response.FailWithMessage("用户被禁止登录", c)
            return
        }
        b.TokenNext(c, *user)
        return
    }
    // 验证码次数+1
    global.BlackCache.Increment(key, 1)
    response.FailWithMessage("验证码错误", c)
}

// TokenNext 登录以后签发jwt
func (b *BaseApi) TokenNext(c *gin.Context, user system.SysUser) {
    j := &utils.JWT{SigningKey: []byte(global.GVA_CONFIG.JWT.SigningKey)} // 唯一签名
    claims := j.CreateClaims(systemReq.BaseClaims{
        UUID:        user.UUID,
        ID:          user.ID,
        NickName:    user.NickName,
        Username:    user.Username,
        AuthorityId: user.AuthorityId,
    })
    token, err := j.CreateToken(claims)
    if err != nil {
        global.GVA_LOG.Error("获取token失败!", zap.Error(err))
        response.FailWithMessage("获取token失败", c)
        return
    }
    if !global.GVA_CONFIG.System.UseMultipoint {
        response.OkWithDetailed(systemRes.LoginResponse{
            User:      user,
            Token:     token,
            ExpiresAt: claims.RegisteredClaims.ExpiresAt.Unix() * 1000,
        }, "登录成功", c)
        return
    }

    if jwtStr, err := jwtService.GetRedisJWT(user.Username); err == redis.Nil {
        if err := jwtService.SetRedisJWT(token, user.Username); err != nil {
            global.GVA_LOG.Error("设置登录状态失败!", zap.Error(err))
            response.FailWithMessage("设置登录状态失败", c)
            return
        }
        response.OkWithDetailed(systemRes.LoginResponse{
            User:      user,
            Token:     token,
            ExpiresAt: claims.RegisteredClaims.ExpiresAt.Unix() * 1000,
        }, "登录成功", c)
    } else if err != nil {
        global.GVA_LOG.Error("设置登录状态失败!", zap.Error(err))
        response.FailWithMessage("设置登录状态失败", c)
    } else {
        var blackJWT system.JwtBlacklist
        blackJWT.Jwt = jwtStr
        if err := jwtService.JsonInBlacklist(blackJWT); err != nil {
            response.FailWithMessage("jwt作废失败", c)
            return
        }
        if err := jwtService.SetRedisJWT(token, user.Username); err != nil {
            response.FailWithMessage("设置登录状态失败", c)
            return
        }
        response.OkWithDetailed(systemRes.LoginResponse{
            User:      user,
            Token:     token,
            ExpiresAt: claims.RegisteredClaims.ExpiresAt.Unix() * 1000,
        }, "登录成功", c)
    }
}

// Register
// @Tags     SysUser
// @Summary  用户注册账号
// @Produce   application/json
// @Param    data  body      systemReq.Register                                            true  "用户名, 昵称, 密码, 角色ID"
// @Success  200   {object}  response.Response{data=systemRes.SysUserResponse,msg=string}  "用户注册账号,返回包括用户信息"
// @Router   /user/admin_register [post]
func (b *BaseApi) Register(c *gin.Context) {
    var r systemReq.Register
    err := c.ShouldBindJSON(&r)
    if err != nil {
        response.FailWithMessage(err.Error(), c)
        return
    }
    err = utils.Verify(r, utils.RegisterVerify)
    if err != nil {
        response.FailWithMessage(err.Error(), c)
        return
    }
    var authorities []system.SysAuthority
    for _, v := range r.AuthorityIds {
        authorities = append(authorities, system.SysAuthority{
            AuthorityId: v,
        })
    }
    user := &system.SysUser{Username: r.Username, NickName: r.NickName, Password: r.Password, HeaderImg: r.HeaderImg, AuthorityId: r.AuthorityId, Authorities: authorities, Enable: r.Enable, Phone: r.Phone, Email: r.Email}
    userReturn, err := userService.Register(*user)
    if err != nil {
        global.GVA_LOG.Error("注册失败!", zap.Error(err))
        response.FailWithDetailed(systemRes.SysUserResponse{User: userReturn}, "注册失败", c)
        return
    }
    response.OkWithDetailed(systemRes.SysUserResponse{User: userReturn}, "注册成功", c)
}

// ChangePassword
// @Tags      SysUser
// @Summary   用户修改密码
// @Security  ApiKeyAuth
// @Produce  application/json
// @Param     data  body      systemReq.ChangePasswordReq    true  "用户名, 原密码, 新密码"
// @Success   200   {object}  response.Response{msg=string}  "用户修改密码"
// @Router    /user/changePassword [post]
func (b *BaseApi) ChangePassword(c *gin.Context) {
    var req systemReq.ChangePasswordReq
    err := c.ShouldBindJSON(&req)
    if err != nil {
        response.FailWithMessage(err.Error(), c)
        return
    }
    err = utils.Verify(req, utils.ChangePasswordVerify)
    if err != nil {
        response.FailWithMessage(err.Error(), c)
        return
    }
    uid := utils.GetUserID(c)
    u := &system.SysUser{GVA_MODEL: global.GVA_MODEL{ID: uid}, Password: req.Password}
    _, err = userService.ChangePassword(u, req.NewPassword)
    if err != nil {
        global.GVA_LOG.Error("修改失败!", zap.Error(err))
        response.FailWithMessage("修改失败，原密码与当前账户不符", c)
        return
    }
    response.OkWithMessage("修改成功", c)
}

// GetUserList
// @Tags      SysUser
// @Summary   分页获取用户列表
// @Security  ApiKeyAuth
// @accept    application/json
// @Produce   application/json
// @Param     data  body      request.PageInfo                                        true  "页码, 每页大小"
// @Success   200   {object}  response.Response{data=response.PageResult,msg=string}  "分页获取用户列表,返回包括列表,总数,页码,每页数量"
// @Router    /user/getUserList [post]
func (b *BaseApi) GetUserList(c *gin.Context) {
    var pageInfo request.PageInfo
    err := c.ShouldBindJSON(&pageInfo)
    if err != nil {
        response.FailWithMessage(err.Error(), c)
        return
    }
    err = utils.Verify(pageInfo, utils.PageInfoVerify)
    if err != nil {
        response.FailWithMessage(err.Error(), c)
        return
    }
    list, total, err := userService.GetUserInfoList(pageInfo)
    if err != nil {
        global.GVA_LOG.Error("获取失败!", zap.Error(err))
        response.FailWithMessage("获取失败", c)
        return
    }
    response.OkWithDetailed(response.PageResult{
        List:     list,
        Total:    total,
        Page:     pageInfo.Page,
        PageSize: pageInfo.PageSize,
    }, "获取成功", c)
}

// SetUserAuthority
// @Tags      SysUser
// @Summary   更改用户权限
// @Security  ApiKeyAuth
// @accept    application/json
// @Produce   application/json
// @Param     data  body      systemReq.SetUserAuth          true  "用户UUID, 角色ID"
// @Success   200   {object}  response.Response{msg=string}  "设置用户权限"
// @Router    /user/setUserAuthority [post]
func (b *BaseApi) SetUserAuthority(c *gin.Context) {
    var sua systemReq.SetUserAuth
    err := c.ShouldBindJSON(&sua)
    if err != nil {
        response.FailWithMessage(err.Error(), c)
        return
    }
    if UserVerifyErr := utils.Verify(sua, utils.SetUserAuthorityVerify); UserVerifyErr != nil {
        response.FailWithMessage(UserVerifyErr.Error(), c)
        return
    }
    userID := utils.GetUserID(c)
    err = userService.SetUserAuthority(userID, sua.AuthorityId)
    if err != nil {
        global.GVA_LOG.Error("修改失败!", zap.Error(err))
        response.FailWithMessage(err.Error(), c)
        return
    }
    claims := utils.GetUserInfo(c)
    j := &utils.JWT{SigningKey: []byte(global.GVA_CONFIG.JWT.SigningKey)} // 唯一签名
    claims.AuthorityId = sua.AuthorityId
    if token, err := j.CreateToken(*claims); err != nil {
        global.GVA_LOG.Error("修改失败!", zap.Error(err))
        response.FailWithMessage(err.Error(), c)
    } else {
        c.Header("new-token", token)
        c.Header("new-expires-at", strconv.FormatInt(claims.ExpiresAt.Unix(), 10))
        response.OkWithMessage("修改成功", c)
    }
}

// SetUserAuthorities
// @Tags      SysUser
// @Summary   设置用户权限
// @Security  ApiKeyAuth
// @accept    application/json
// @Produce   application/json
// @Param     data  body      systemReq.SetUserAuthorities   true  "用户UUID, 角色ID"
// @Success   200   {object}  response.Response{msg=string}  "设置用户权限"
// @Router    /user/setUserAuthorities [post]
func (b *BaseApi) SetUserAuthorities(c *gin.Context) {
    var sua systemReq.SetUserAuthorities
    err := c.ShouldBindJSON(&sua)
    if err != nil {
        response.FailWithMessage(err.Error(), c)
        return
    }
    err = userService.SetUserAuthorities(sua.ID, sua.AuthorityIds)
    if err != nil {
        global.GVA_LOG.Error("修改失败!", zap.Error(err))
        response.FailWithMessage("修改失败", c)
        return
    }
    response.OkWithMessage("修改成功", c)
}

// DeleteUser
// @Tags      SysUser
// @Summary   删除用户
// @Security  ApiKeyAuth
// @accept    application/json
// @Produce   application/json
// @Param     data  body      request.GetById                true  "用户ID"
// @Success   200   {object}  response.Response{msg=string}  "删除用户"
// @Router    /user/deleteUser [delete]
func (b *BaseApi) DeleteUser(c *gin.Context) {
    var reqId request.GetById
    err := c.ShouldBindJSON(&reqId)
    if err != nil {
        response.FailWithMessage(err.Error(), c)
        return
    }
    err = utils.Verify(reqId, utils.IdVerify)
    if err != nil {
        response.FailWithMessage(err.Error(), c)
        return
    }
    jwtId := utils.GetUserID(c)
    if jwtId == uint(reqId.ID) {
        response.FailWithMessage("删除失败, 自杀失败", c)
        return
    }
    err = userService.DeleteUser(reqId.ID)
    if err != nil {
        global.GVA_LOG.Error("删除失败!", zap.Error(err))
        response.FailWithMessage("删除失败", c)
        return
    }
    response.OkWithMessage("删除成功", c)
}

// SetUserInfo
// @Tags      SysUser
// @Summary   设置用户信息
// @Security  ApiKeyAuth
// @accept    application/json
// @Produce   application/json
// @Param     data  body      system.SysUser                                             true  "ID, 用户名, 昵称, 头像链接"
// @Success   200   {object}  response.Response{data=map[string]interface{},msg=string}  "设置用户信息"
// @Router    /user/setUserInfo [put]
func (b *BaseApi) SetUserInfo(c *gin.Context) {
    var user systemReq.ChangeUserInfo
    err := c.ShouldBindJSON(&user)
    if err != nil {
        response.FailWithMessage(err.Error(), c)
        return
    }
    err = utils.Verify(user, utils.IdVerify)
    if err != nil {
        response.FailWithMessage(err.Error(), c)
        return
    }

    if len(user.AuthorityIds) != 0 {
        err = userService.SetUserAuthorities(user.ID, user.AuthorityIds)
        if err != nil {
            global.GVA_LOG.Error("设置失败!", zap.Error(err))
            response.FailWithMessage("设置失败", c)
            return
        }
    }
    err = userService.SetUserInfo(system.SysUser{
        GVA_MODEL: global.GVA_MODEL{
            ID: user.ID,
        },
        NickName:  user.NickName,
        HeaderImg: user.HeaderImg,
        Phone:     user.Phone,
        Email:     user.Email,
        SideMode:  user.SideMode,
        Enable:    user.Enable,
    })
    if err != nil {
        global.GVA_LOG.Error("设置失败!", zap.Error(err))
        response.FailWithMessage("设置失败", c)
        return
    }
    response.OkWithMessage("设置成功", c)
}

// SetSelfInfo
// @Tags      SysUser
// @Summary   设置用户信息
// @Security  ApiKeyAuth
// @accept    application/json
// @Produce   application/json
// @Param     data  body      system.SysUser                                             true  "ID, 用户名, 昵称, 头像链接"
// @Success   200   {object}  response.Response{data=map[string]interface{},msg=string}  "设置用户信息"
// @Router    /user/SetSelfInfo [put]
func (b *BaseApi) SetSelfInfo(c *gin.Context) {
    var user systemReq.ChangeUserInfo
    err := c.ShouldBindJSON(&user)
    if err != nil {
        response.FailWithMessage(err.Error(), c)
        return
    }
    user.ID = utils.GetUserID(c)
    err = userService.SetSelfInfo(system.SysUser{
        GVA_MODEL: global.GVA_MODEL{
            ID: user.ID,
        },
        NickName:  user.NickName,
        HeaderImg: user.HeaderImg,
        Phone:     user.Phone,
        Email:     user.Email,
        SideMode:  user.SideMode,
        Enable:    user.Enable,
    })
    if err != nil {
        global.GVA_LOG.Error("设置失败!", zap.Error(err))
        response.FailWithMessage("设置失败", c)
        return
    }
    response.OkWithMessage("设置成功", c)
}

// GetUserInfo
// @Tags      SysUser
// @Summary   获取用户信息
// @Security  ApiKeyAuth
// @accept    application/json
// @Produce   application/json
// @Success   200  {object}  response.Response{data=map[string]interface{},msg=string}  "获取用户信息"
// @Router    /user/getUserInfo [get]
func (b *BaseApi) GetUserInfo(c *gin.Context) {
    uuid := utils.GetUserUuid(c)
    ReqUser, err := userService.GetUserInfo(uuid)
    if err != nil {
        global.GVA_LOG.Error("获取失败!", zap.Error(err))
        response.FailWithMessage("获取失败", c)
        return
    }
    response.OkWithDetailed(gin.H{"userInfo": ReqUser}, "获取成功", c)
}

// ResetPassword
// @Tags      SysUser
// @Summary   重置用户密码
// @Security  ApiKeyAuth
// @Produce  application/json
// @Param     data  body      system.SysUser                 true  "ID"
// @Success   200   {object}  response.Response{msg=string}  "重置用户密码"
// @Router    /user/resetPassword [post]
func (b *BaseApi) ResetPassword(c *gin.Context) {
    var user system.SysUser
    err := c.ShouldBindJSON(&user)
    if err != nil {
        response.FailWithMessage(err.Error(), c)
        return
    }
    err = userService.ResetPassword(user.ID)
    if err != nil {
        global.GVA_LOG.Error("重置失败!", zap.Error(err))
        response.FailWithMessage("重置失败"+err.Error(), c)
        return
    }
    response.OkWithMessage("重置成功", c)
}