601 lines
16 KiB
Go
601 lines
16 KiB
Go
package system
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
|
||
"kra/internal/biz/system"
|
||
"kra/internal/server/middleware"
|
||
"kra/pkg/jwt"
|
||
|
||
"github.com/go-kratos/kratos/v2/errors"
|
||
"github.com/go-kratos/kratos/v2/transport/http"
|
||
)
|
||
|
||
// UserService 用户服务
|
||
type UserService struct {
|
||
uc *system.UserUsecase
|
||
jwtPkg *jwt.JWT
|
||
}
|
||
|
||
// NewUserService 创建用户服务
|
||
func NewUserService(uc *system.UserUsecase, jwtPkg *jwt.JWT) *UserService {
|
||
return &UserService{uc: uc, jwtPkg: jwtPkg}
|
||
}
|
||
|
||
// LoginRequest 登录请求
|
||
type LoginRequest struct {
|
||
Username string `json:"username"`
|
||
Password string `json:"password"`
|
||
Captcha string `json:"captcha"`
|
||
CaptchaId string `json:"captchaId"`
|
||
}
|
||
|
||
// LoginResponse 登录响应
|
||
type LoginResponse struct {
|
||
User *UserInfo `json:"user"`
|
||
Token string `json:"token"`
|
||
ExpiresAt int64 `json:"expiresAt"`
|
||
}
|
||
|
||
// UserInfo 用户信息
|
||
type UserInfo struct {
|
||
ID uint `json:"id"`
|
||
UUID string `json:"uuid"`
|
||
Username string `json:"username"`
|
||
NickName string `json:"nickName"`
|
||
SideMode string `json:"sideMode"`
|
||
HeaderImg string `json:"headerImg"`
|
||
BaseColor string `json:"baseColor"`
|
||
AuthorityId uint `json:"authorityId"`
|
||
Phone string `json:"phone"`
|
||
Email string `json:"email"`
|
||
Enable int `json:"enable"`
|
||
OriginSetting json.RawMessage `json:"originSetting,omitempty"`
|
||
Authority *AuthorityInfo `json:"authority,omitempty"`
|
||
Authorities []*AuthorityInfo `json:"authorities,omitempty"`
|
||
}
|
||
|
||
// AuthorityInfo 角色信息
|
||
type AuthorityInfo struct {
|
||
AuthorityId uint `json:"authorityId"`
|
||
AuthorityName string `json:"authorityName"`
|
||
ParentId *uint `json:"parentId,omitempty"`
|
||
DefaultRouter string `json:"defaultRouter"`
|
||
}
|
||
|
||
// Login 用户登录
|
||
func (s *UserService) Login(ctx context.Context, req *LoginRequest) (*LoginResponse, error) {
|
||
user, err := s.uc.Login(ctx, req.Username, req.Password)
|
||
if err != nil {
|
||
return nil, errors.Unauthorized("LOGIN_FAILED", err.Error())
|
||
}
|
||
|
||
if user.Enable != 1 {
|
||
return nil, errors.Forbidden("USER_DISABLED", "用户被禁止登录")
|
||
}
|
||
|
||
// 生成 JWT token
|
||
claims := s.jwtPkg.CreateClaims(jwt.BaseClaims{
|
||
UUID: user.UUID.String(),
|
||
ID: uint(user.ID),
|
||
Username: user.Username,
|
||
NickName: user.NickName,
|
||
AuthorityID: user.AuthorityId,
|
||
})
|
||
token, err := s.jwtPkg.CreateToken(claims.BaseClaims)
|
||
if err != nil {
|
||
return nil, errors.InternalServer("TOKEN_ERROR", "生成token失败")
|
||
}
|
||
|
||
return &LoginResponse{
|
||
User: toUserInfo(user),
|
||
Token: token,
|
||
ExpiresAt: claims.ExpiresAt.UnixMilli(),
|
||
}, nil
|
||
}
|
||
|
||
// RegisterRequest 注册请求
|
||
type RegisterRequest struct {
|
||
Username string `json:"username"`
|
||
Password string `json:"password"`
|
||
NickName string `json:"nickName"`
|
||
HeaderImg string `json:"headerImg"`
|
||
AuthorityId uint `json:"authorityId"`
|
||
AuthorityIds []uint `json:"authorityIds"`
|
||
Phone string `json:"phone"`
|
||
Email string `json:"email"`
|
||
Enable int `json:"enable"`
|
||
}
|
||
|
||
// Register 用户注册
|
||
func (s *UserService) Register(ctx context.Context, req *RegisterRequest) (*UserInfo, error) {
|
||
user := &system.User{
|
||
Username: req.Username,
|
||
Password: req.Password,
|
||
NickName: req.NickName,
|
||
HeaderImg: req.HeaderImg,
|
||
AuthorityId: req.AuthorityId,
|
||
Phone: req.Phone,
|
||
Email: req.Email,
|
||
Enable: req.Enable,
|
||
}
|
||
|
||
created, err := s.uc.Register(ctx, user)
|
||
if err != nil {
|
||
return nil, errors.BadRequest("REGISTER_FAILED", err.Error())
|
||
}
|
||
|
||
return toUserInfo(created), nil
|
||
}
|
||
|
||
// ChangePasswordRequest 修改密码请求
|
||
type ChangePasswordRequest struct {
|
||
Password string `json:"password"`
|
||
NewPassword string `json:"newPassword"`
|
||
}
|
||
|
||
// ChangePassword 修改密码
|
||
func (s *UserService) ChangePassword(ctx context.Context, userID uint, req *ChangePasswordRequest) error {
|
||
return s.uc.ChangePassword(ctx, userID, req.Password, req.NewPassword)
|
||
}
|
||
|
||
// ResetPasswordRequest 重置密码请求
|
||
type ResetPasswordRequest struct {
|
||
ID uint `json:"id"`
|
||
Password string `json:"password"`
|
||
}
|
||
|
||
// ResetPassword 重置密码
|
||
func (s *UserService) ResetPassword(ctx context.Context, req *ResetPasswordRequest) error {
|
||
return s.uc.ResetPassword(ctx, req.ID, req.Password)
|
||
}
|
||
|
||
// GetUserInfo 获取用户信息
|
||
func (s *UserService) GetUserInfo(ctx context.Context, uuid string) (*UserInfo, error) {
|
||
user, err := s.uc.GetUserInfo(ctx, uuid)
|
||
if err != nil {
|
||
return nil, errors.NotFound("USER_NOT_FOUND", err.Error())
|
||
}
|
||
return toUserInfo(user), nil
|
||
}
|
||
|
||
// GetUserListRequest 获取用户列表请求
|
||
type GetUserListRequest struct {
|
||
Page int `json:"page"`
|
||
PageSize int `json:"pageSize"`
|
||
Username string `json:"username"`
|
||
NickName string `json:"nickName"`
|
||
Phone string `json:"phone"`
|
||
Email string `json:"email"`
|
||
}
|
||
|
||
// GetUserListResponse 获取用户列表响应
|
||
type GetUserListResponse struct {
|
||
List []*UserInfo `json:"list"`
|
||
Total int64 `json:"total"`
|
||
Page int `json:"page"`
|
||
PageSize int `json:"pageSize"`
|
||
}
|
||
|
||
// GetUserList 获取用户列表
|
||
func (s *UserService) GetUserList(ctx context.Context, req *GetUserListRequest) (*GetUserListResponse, error) {
|
||
filters := make(map[string]string)
|
||
if req.Username != "" {
|
||
filters["username"] = req.Username
|
||
}
|
||
if req.NickName != "" {
|
||
filters["nick_name"] = req.NickName
|
||
}
|
||
if req.Phone != "" {
|
||
filters["phone"] = req.Phone
|
||
}
|
||
if req.Email != "" {
|
||
filters["email"] = req.Email
|
||
}
|
||
|
||
users, total, err := s.uc.GetUserList(ctx, req.Page, req.PageSize, filters)
|
||
if err != nil {
|
||
return nil, errors.InternalServer("LIST_ERROR", err.Error())
|
||
}
|
||
|
||
list := make([]*UserInfo, len(users))
|
||
for i, u := range users {
|
||
list[i] = toUserInfo(u)
|
||
}
|
||
|
||
return &GetUserListResponse{
|
||
List: list,
|
||
Total: total,
|
||
Page: req.Page,
|
||
PageSize: req.PageSize,
|
||
}, nil
|
||
}
|
||
|
||
// SetUserInfoRequest 设置用户信息请求（管理员用）
|
||
type SetUserInfoRequest struct {
|
||
ID uint `json:"id"`
|
||
NickName string `json:"nickName"`
|
||
HeaderImg string `json:"headerImg"`
|
||
Phone string `json:"phone"`
|
||
Email string `json:"email"`
|
||
Enable int `json:"enable"`
|
||
AuthorityIds []uint `json:"authorityIds"`
|
||
}
|
||
|
||
// SetUserInfo 设置用户信息
|
||
func (s *UserService) SetUserInfo(ctx context.Context, adminAuthorityID uint, req *SetUserInfoRequest) error {
|
||
// 如果提供了AuthorityIds，先设置用户角色（与GVA保持一致）
|
||
if len(req.AuthorityIds) > 0 {
|
||
if err := s.uc.SetUserAuthorities(ctx, adminAuthorityID, req.ID, req.AuthorityIds); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
user := &system.User{
|
||
ID: req.ID,
|
||
NickName: req.NickName,
|
||
HeaderImg: req.HeaderImg,
|
||
Phone: req.Phone,
|
||
Email: req.Email,
|
||
Enable: req.Enable,
|
||
}
|
||
return s.uc.SetUserInfo(ctx, user)
|
||
}
|
||
|
||
// SetSelfInfoRequest 设置自己信息请求（用户用）
|
||
type SetSelfInfoRequest struct {
|
||
NickName string `json:"nickName"`
|
||
HeaderImg string `json:"headerImg"`
|
||
Phone string `json:"phone"`
|
||
Email string `json:"email"`
|
||
SideMode string `json:"sideMode"`
|
||
BaseColor string `json:"baseColor"`
|
||
}
|
||
|
||
// SetSelfInfo 设置自己的信息
|
||
func (s *UserService) SetSelfInfo(ctx context.Context, userID uint, req *SetSelfInfoRequest) error {
|
||
user := &system.User{
|
||
ID: userID,
|
||
NickName: req.NickName,
|
||
HeaderImg: req.HeaderImg,
|
||
Phone: req.Phone,
|
||
Email: req.Email,
|
||
SideMode: req.SideMode,
|
||
BaseColor: req.BaseColor,
|
||
}
|
||
return s.uc.SetSelfInfo(ctx, user)
|
||
}
|
||
|
||
// SetSelfSetting 设置自己的配置
|
||
func (s *UserService) SetSelfSetting(ctx context.Context, userID uint, setting json.RawMessage) error {
|
||
return s.uc.SetSelfSetting(ctx, userID, setting)
|
||
}
|
||
|
||
// DeleteUser 删除用户
|
||
func (s *UserService) DeleteUser(ctx context.Context, id uint) error {
|
||
return s.uc.DeleteUser(ctx, id)
|
||
}
|
||
|
||
// SetUserAuthorityRequest 设置用户角色请求
|
||
type SetUserAuthorityRequest struct {
|
||
AuthorityId uint `json:"authorityId"`
|
||
}
|
||
|
||
// SetUserAuthorityResponse 设置用户角色响应
|
||
type SetUserAuthorityResponse struct {
|
||
Token string `json:"token"`
|
||
ExpiresAt int64 `json:"expiresAt"`
|
||
}
|
||
|
||
// SetUserAuthority 设置用户角色（切换角色）- 返回新token
|
||
func (s *UserService) SetUserAuthority(ctx context.Context, userID uint, uuid string, username string, nickName string, req *SetUserAuthorityRequest) (*SetUserAuthorityResponse, error) {
|
||
if err := s.uc.SetUserAuthority(ctx, userID, req.AuthorityId); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 生成新的JWT token（与GVA保持一致）
|
||
claims := s.jwtPkg.CreateClaims(jwt.BaseClaims{
|
||
UUID: uuid,
|
||
ID: userID,
|
||
Username: username,
|
||
NickName: nickName,
|
||
AuthorityID: req.AuthorityId,
|
||
})
|
||
token, err := s.jwtPkg.CreateToken(claims.BaseClaims)
|
||
if err != nil {
|
||
return nil, errors.InternalServer("TOKEN_ERROR", "生成token失败")
|
||
}
|
||
|
||
return &SetUserAuthorityResponse{
|
||
Token: token,
|
||
ExpiresAt: claims.ExpiresAt.UnixMilli(),
|
||
}, nil
|
||
}
|
||
|
||
// SetUserAuthoritiesRequest 设置用户多角色请求
|
||
type SetUserAuthoritiesRequest struct {
|
||
ID uint `json:"id"`
|
||
AuthorityIds []uint `json:"authorityIds"`
|
||
}
|
||
|
||
// SetUserAuthorities 设置用户多角色
|
||
func (s *UserService) SetUserAuthorities(ctx context.Context, adminAuthorityID uint, req *SetUserAuthoritiesRequest) error {
|
||
return s.uc.SetUserAuthorities(ctx, adminAuthorityID, req.ID, req.AuthorityIds)
|
||
}
|
||
|
||
// 转换函数
|
||
func toUserInfo(u *system.User) *UserInfo {
|
||
info := &UserInfo{
|
||
ID: u.ID,
|
||
UUID: u.UUID.String(),
|
||
Username: u.Username,
|
||
NickName: u.NickName,
|
||
SideMode: u.SideMode,
|
||
HeaderImg: u.HeaderImg,
|
||
BaseColor: u.BaseColor,
|
||
AuthorityId: u.AuthorityId,
|
||
Phone: u.Phone,
|
||
Email: u.Email,
|
||
Enable: u.Enable,
|
||
OriginSetting: u.OriginSetting,
|
||
}
|
||
|
||
if u.Authority != nil {
|
||
info.Authority = &AuthorityInfo{
|
||
AuthorityId: u.Authority.AuthorityId,
|
||
AuthorityName: u.Authority.AuthorityName,
|
||
ParentId: u.Authority.ParentId,
|
||
DefaultRouter: u.Authority.DefaultRouter,
|
||
}
|
||
}
|
||
|
||
if len(u.Authorities) > 0 {
|
||
info.Authorities = make([]*AuthorityInfo, len(u.Authorities))
|
||
for i, a := range u.Authorities {
|
||
info.Authorities[i] = &AuthorityInfo{
|
||
AuthorityId: a.AuthorityId,
|
||
AuthorityName: a.AuthorityName,
|
||
ParentId: a.ParentId,
|
||
DefaultRouter: a.DefaultRouter,
|
||
}
|
||
}
|
||
}
|
||
|
||
return info
|
||
}
|
||
|
||
// RegisterRoutes 注册路由
|
||
func (s *UserService) RegisterRoutes(srv *http.Server) {
|
||
r := srv.Route("/")
|
||
|
||
// 公开接口
|
||
r.POST("/base/login", s.handleLogin)
|
||
|
||
// 需要认证的接口
|
||
r.POST("/user/register", s.handleRegister)
|
||
r.POST("/user/changePassword", s.handleChangePassword)
|
||
r.POST("/user/resetPassword", s.handleResetPassword)
|
||
r.GET("/user/getUserInfo", s.handleGetUserInfo)
|
||
r.POST("/user/getUserList", s.handleGetUserList)
|
||
r.PUT("/user/setUserInfo", s.handleSetUserInfo)
|
||
r.PUT("/user/setSelfInfo", s.handleSetSelfInfo)
|
||
r.PUT("/user/setSelfSetting", s.handleSetSelfSetting)
|
||
r.DELETE("/user/deleteUser", s.handleDeleteUser)
|
||
r.POST("/user/setUserAuthority", s.handleSetUserAuthority)
|
||
r.POST("/user/setUserAuthorities", s.handleSetUserAuthorities)
|
||
}
|
||
|
||
// HTTP Handlers
|
||
func (s *UserService) handleLogin(ctx http.Context) error {
|
||
var req LoginRequest
|
||
if err := ctx.Bind(&req); err != nil {
|
||
return err
|
||
}
|
||
resp, err := s.Login(ctx, &req)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
return ctx.Result(200, map[string]any{
|
||
"code": 0,
|
||
"msg": "登录成功",
|
||
"data": resp,
|
||
})
|
||
}
|
||
|
||
func (s *UserService) handleRegister(ctx http.Context) error {
|
||
var req RegisterRequest
|
||
if err := ctx.Bind(&req); err != nil {
|
||
return err
|
||
}
|
||
resp, err := s.Register(ctx, &req)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
return ctx.Result(200, map[string]any{
|
||
"code": 0,
|
||
"msg": "注册成功",
|
||
"data": resp,
|
||
})
|
||
}
|
||
|
||
func (s *UserService) handleChangePassword(ctx http.Context) error {
|
||
var req ChangePasswordRequest
|
||
if err := ctx.Bind(&req); err != nil {
|
||
return err
|
||
}
|
||
userID := middleware.GetUserID(ctx)
|
||
if userID == 0 {
|
||
return errors.Unauthorized("UNAUTHORIZED", "请先登录")
|
||
}
|
||
if err := s.ChangePassword(ctx, userID, &req); err != nil {
|
||
return err
|
||
}
|
||
return ctx.Result(200, map[string]any{
|
||
"code": 0,
|
||
"msg": "修改成功",
|
||
})
|
||
}
|
||
|
||
func (s *UserService) handleResetPassword(ctx http.Context) error {
|
||
var req ResetPasswordRequest
|
||
if err := ctx.Bind(&req); err != nil {
|
||
return err
|
||
}
|
||
if err := s.ResetPassword(ctx, &req); err != nil {
|
||
return err
|
||
}
|
||
return ctx.Result(200, map[string]any{
|
||
"code": 0,
|
||
"msg": "重置成功",
|
||
})
|
||
}
|
||
|
||
func (s *UserService) handleGetUserInfo(ctx http.Context) error {
|
||
claims, ok := middleware.GetClaims(ctx)
|
||
if !ok {
|
||
return errors.Unauthorized("UNAUTHORIZED", "请先登录")
|
||
}
|
||
resp, err := s.GetUserInfo(ctx, claims.UUID)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
return ctx.Result(200, map[string]any{
|
||
"code": 0,
|
||
"msg": "获取成功",
|
||
"data": map[string]any{"userInfo": resp},
|
||
})
|
||
}
|
||
|
||
func (s *UserService) handleGetUserList(ctx http.Context) error {
|
||
var req GetUserListRequest
|
||
if err := ctx.Bind(&req); err != nil {
|
||
return err
|
||
}
|
||
resp, err := s.GetUserList(ctx, &req)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
return ctx.Result(200, map[string]any{
|
||
"code": 0,
|
||
"msg": "获取成功",
|
||
"data": resp,
|
||
})
|
||
}
|
||
|
||
func (s *UserService) handleSetUserInfo(ctx http.Context) error {
|
||
var req SetUserInfoRequest
|
||
if err := ctx.Bind(&req); err != nil {
|
||
return err
|
||
}
|
||
adminAuthorityID := middleware.GetAuthorityID(ctx)
|
||
if adminAuthorityID == 0 {
|
||
return errors.Unauthorized("UNAUTHORIZED", "请先登录")
|
||
}
|
||
if err := s.SetUserInfo(ctx, adminAuthorityID, &req); err != nil {
|
||
return err
|
||
}
|
||
return ctx.Result(200, map[string]any{
|
||
"code": 0,
|
||
"msg": "设置成功",
|
||
})
|
||
}
|
||
|
||
func (s *UserService) handleSetSelfInfo(ctx http.Context) error {
|
||
var req SetSelfInfoRequest
|
||
if err := ctx.Bind(&req); err != nil {
|
||
return err
|
||
}
|
||
userID := middleware.GetUserID(ctx)
|
||
if userID == 0 {
|
||
return errors.Unauthorized("UNAUTHORIZED", "请先登录")
|
||
}
|
||
if err := s.SetSelfInfo(ctx, userID, &req); err != nil {
|
||
return err
|
||
}
|
||
return ctx.Result(200, map[string]any{
|
||
"code": 0,
|
||
"msg": "设置成功",
|
||
})
|
||
}
|
||
|
||
func (s *UserService) handleSetSelfSetting(ctx http.Context) error {
|
||
var req json.RawMessage
|
||
if err := ctx.Bind(&req); err != nil {
|
||
return err
|
||
}
|
||
userID := middleware.GetUserID(ctx)
|
||
if userID == 0 {
|
||
return errors.Unauthorized("UNAUTHORIZED", "请先登录")
|
||
}
|
||
if err := s.SetSelfSetting(ctx, userID, req); err != nil {
|
||
return err
|
||
}
|
||
return ctx.Result(200, map[string]any{
|
||
"code": 0,
|
||
"msg": "设置成功",
|
||
})
|
||
}
|
||
|
||
func (s *UserService) handleDeleteUser(ctx http.Context) error {
|
||
var req struct {
|
||
ID uint `json:"id"`
|
||
}
|
||
if err := ctx.Bind(&req); err != nil {
|
||
return err
|
||
}
|
||
// 不能删除自己
|
||
userID := middleware.GetUserID(ctx)
|
||
if userID == req.ID {
|
||
return errors.BadRequest("DELETE_SELF", "删除失败, 无法删除自己")
|
||
}
|
||
if err := s.DeleteUser(ctx, req.ID); err != nil {
|
||
return err
|
||
}
|
||
return ctx.Result(200, map[string]any{
|
||
"code": 0,
|
||
"msg": "删除成功",
|
||
})
|
||
}
|
||
|
||
func (s *UserService) handleSetUserAuthority(ctx http.Context) error {
|
||
var req SetUserAuthorityRequest
|
||
if err := ctx.Bind(&req); err != nil {
|
||
return err
|
||
}
|
||
claims, ok := middleware.GetClaims(ctx)
|
||
if !ok {
|
||
return errors.Unauthorized("UNAUTHORIZED", "请先登录")
|
||
}
|
||
resp, err := s.SetUserAuthority(ctx, claims.BaseClaims.ID, claims.UUID, claims.Username, claims.NickName, &req)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
// 设置响应头（与GVA保持一致）
|
||
ctx.Response().Header().Set("new-token", resp.Token)
|
||
ctx.Response().Header().Set("new-expires-at", fmt.Sprintf("%d", resp.ExpiresAt/1000))
|
||
return ctx.Result(200, map[string]any{
|
||
"code": 0,
|
||
"msg": "修改成功",
|
||
})
|
||
}
|
||
|
||
func (s *UserService) handleSetUserAuthorities(ctx http.Context) error {
|
||
var req SetUserAuthoritiesRequest
|
||
if err := ctx.Bind(&req); err != nil {
|
||
return err
|
||
}
|
||
adminAuthorityID := middleware.GetAuthorityID(ctx)
|
||
if adminAuthorityID == 0 {
|
||
return errors.Unauthorized("UNAUTHORIZED", "请先登录")
|
||
}
|
||
if err := s.SetUserAuthorities(ctx, adminAuthorityID, &req); err != nil {
|
||
return err
|
||
}
|
||
return ctx.Result(200, map[string]any{
|
||
"code": 0,
|
||
"msg": "修改成功",
|
||
})
|
||
}
|