opms_backend/opms_admin/app/handler/auth.go

package handler

import (
	"context"
	"dashoo.cn/common_definition/admin/user_def"
	"dashoo.cn/common_definition/auth"
	"dashoo.cn/common_definition/comm_def"
	"dashoo.cn/micro/app/service"
	"dashoo.cn/opms_libary/gtoken"
	"dashoo.cn/opms_libary/micro_srv"
	"dashoo.cn/opms_libary/myerrors"
	"github.com/gogf/gf/encoding/gjson"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/os/glog"
	"github.com/gogf/gf/util/gconv"
)

type AuthHandler struct{}

func init() {
	// 启动gtoken
	gtoken.GFToken = &gtoken.GfToken{
		Timeout:    g.Config().GetInt("gtoken.timeout"), // 15天
		EncryptKey: []byte(g.Config().GetString("gtoken.encrypt-key")),
		CacheMode:  g.Config().GetInt8("gtoken.cache-mode"),
		MultiLogin: g.Config().GetBool("gtoken.multi-login"),
	}
	gtoken.GFToken.Start()
}

// Login 用户登录验证
func (h *AuthHandler) Login(ctx context.Context, req *user_def.LoginReq, rsp *comm_def.CommonMsg) error {
	// 参数验证
	if req.UserName == "" || req.Password == "" {
		return myerrors.TipsError("请求参数不存在。")
	}
	userService, err := service.NewUserService(ctx)
	if err != nil {
		return err
	}
	userInfo, err := userService.Login(req.UserName, req.Password)
	loginLogService, _ := service.NewLoginLogService(ctx)
	loginLogService.Invoke(ctx, req.UserName, err)
	if err != nil {
		return err
	}

	tenant, _ := micro_srv.GetTenant(ctx)
	tokenResp := gtoken.GFToken.GetOrGenToken(tenant, userInfo.UserName, userInfo.Uuid, userInfo)
	rsp.Msg = tokenResp.Msg

	tokenData := gconv.Map(tokenResp.Data)
	tokenData["isFirstLogin"] = userInfo.IsFirstLogin
	rsp.Data = tokenData
	return nil
}

// LogOut 退出登录
func (h *AuthHandler) LogOut(ctx context.Context, req interface{}, rsp *comm_def.CommonMsg) error {
	token, err := micro_srv.GetToken(ctx)
	if err != nil {
		return err
	} else if token == "" {
		return myerrors.TipsError("请求参数不存在。")
	}
	tokenResp := gtoken.GFToken.RemoveToken(token)
	if err != nil {
		return err
	}
	rsp.Msg = tokenResp.Msg
	rsp.Data = tokenResp.Data
	return nil
}

func (h *AuthHandler) GetToken(ctx context.Context, req *auth.Request, rsp *comm_def.CommonMsg) (err error) {
	glog.Info("Received AuthHandler.GetToken request, UserKey:", req.UserKey, " @ ", req.Tenant)
	// 获取Data，换成对象
	var json interface{}
	if req.Data != "" {
		json, err = gjson.DecodeToJson(req.Data)
		if err != nil {
			return err
		}
	}
	tokenResp := gtoken.GFToken.GetOrGenToken(req.Tenant, req.UserKey, req.Uuid, json)
	if err := gconv.Struct(tokenResp, rsp); err != nil {
		return err
	}
	glog.Info(tokenResp.DataString())
	return nil
}

func (h *AuthHandler) RemoveToken(ctx context.Context, reqToken string, rsp *comm_def.CommonMsg) error {
	glog.Info("Received AuthHandler.RemoveToken request, token:", reqToken)
	tokenResp := gtoken.GFToken.RemoveToken(reqToken)
	if err := gconv.Struct(tokenResp, rsp); err != nil {
		return err
	}
	return nil
}

func (h *AuthHandler) ValidToken(ctx context.Context, reqToken string, rsp *comm_def.CommonMsg) error {
	glog.Info("Received AuthHandler.ValidToken request, token:", reqToken)
	tokenResp := gtoken.GFToken.ValidToken(reqToken)
	//tokenData := gconv.Map(tokenResp.Data)
	//userInfo := tokenData["data"].(*request.UserInfo)
	//userService, err := service.NewUserService(ctx)
	//if err != nil {
	//	return err
	//}
	////数据权限
	//userInfo.DataScope, err = userService.GetDataScope(userInfo.Id)
	//if err != nil {
	//	g.Log().Error(err)
	//	return myerrors.TipsError("获取用户数据权限失败")
	//}
	if err := gconv.Struct(tokenResp, rsp); err != nil {
		return err
	}
	return nil
}