login and register

ueumd · ueumd · commit b21eae893b4b · 2023-11-29T19:23:59.000+08:00
diff --git a/api/controller/common/common.go b/api/controller/common/common.go
@@ -16,7 +16,8 @@ type CommonController struct {
 
 func init() {
 	c := &CommonController{}
-	commGroup := router.GetWebRouter().Group("/v1/common")
+	r := router.GetWebRouterGroup()
+	commGroup := r.Group("/common")
 	commGroup.GET("/getSystemDate", c.GetSystemDate)
 	commGroup.GET("/getDictionaryData", c.getDictionaryData)
 	commGroup.GET("/getAllSupportCityList", c.GetAllSupportCityList)
diff --git a/api/controller/user/user.go b/api/controller/user/user.go
@@ -3,16 +3,39 @@ package user
 import (
 	"github.com/gin-gonic/gin"
 	"wow-admin/api/router"
+	"wow-admin/model/dto"
+	"wow-admin/service"
+	"wow-admin/utils"
 	"wow-admin/utils/result"
 )
 
 type UserController struct {
+	userService service.UserService
 }
 
 func init() {
 	u := &UserController{}
-	loginGroup := router.GetWebRouter().Group("v1/user")
-	loginGroup.GET("getUserInfo", u.getUserInfo)
+	base := router.GetWebRouterGroup()
+	base.POST("/login", u.login)
+	base.POST("/register", u.register)
+
+	userRouter := base.Group("/user")
+	userRouter.GET("getUserInfo", u.getUserInfo)
+}
+
+// 后台登录
+func (c *UserController) login(ctx *gin.Context) {
+	loginReq := utils.BindValidJson[dto.Login](ctx)
+
+	loginVO, code := c.userService.Login(ctx, loginReq.Username, loginReq.Password)
+
+	result.SendData(ctx, code, loginVO)
+}
+
+func (c *UserController) register(ctx *gin.Context) {
+	registerReq := utils.BindValidJson[dto.Register](ctx)
+	code := c.userService.Register(registerReq)
+	result.SendCode(ctx, code)
 }
 
 func (c *UserController) getUserInfo(ctx *gin.Context) {
diff --git a/api/middleware/auth.go b/api/middleware/auth.go
@@ -10,6 +10,7 @@ import (
 
 func AuthLogin() gin.HandlerFunc {
 	return func(c *gin.Context) {
+
 		utils.Logger.Info(c.Request.URL.Path)
 		requestPath := c.Request.URL.Path
 		needLogin := ignoreRoute(requestPath)
@@ -63,13 +64,14 @@ func AuthLogin() gin.HandlerFunc {
 	}
 }
 
-/*
-*
-白名单路由
-*/
+// 白名单路由
 func ignoreRoute(requestPath string) bool {
-	if strings.HasPrefix(requestPath, "/v1/common") {
-		return true
+	// return true
+	whiteList := []string{"/api/common", "/api/login", "/api/register"}
+	for _, val := range whiteList {
+		if strings.HasPrefix(requestPath, val) {
+			return true
+		}
 	}
 	return false
 }
diff --git a/api/router/router.go b/api/router/router.go
@@ -82,7 +82,7 @@ func InitAndStartWebServer(ctx context.Context, debug bool, wait *utils.WaitGrou
 		ctx:        ctx,
 	}
 	_defaultWebServer.Start()
-	utils.Logger.Info(global.SERVER_NAME+" server started at %s ...", zap.String("backPort", backPort))
+	utils.Logger.Info(global.SERVER_NAME + " server started at http://localhost" + backPort)
 	wait.Wrap(func() {
 		select {
 		case <-ctx.Done():
@@ -94,3 +94,7 @@ func InitAndStartWebServer(ctx context.Context, debug bool, wait *utils.WaitGrou
 func GetWebRouter() *gin.Engine {
 	return _defaultWebRouter
 }
+
+func GetWebRouterGroup() *gin.RouterGroup {
+	return _defaultWebRouter.Group("/api")
+}
diff --git a/dao/base.go b/dao/base.go
@@ -2,7 +2,6 @@ package dao
 
 import (
 	"errors"
-
 	"gorm.io/gorm"
 )
 
diff --git a/model/RBAC.go b/model/RBAC.go
@@ -1,5 +1,11 @@
 package model
 
+import "time"
+
+/**
+Role-Based Access Control
+*/
+
 // 菜单
 type Menu struct {
 	Universal `mapstructure:",squash"`
@@ -13,3 +19,15 @@ type Menu struct {
 	KeepAlive int8   `gorm:"type:tinyint(1);default:1" json:"keep_alive"`
 	Redirect  string `gorm:"type:varchar(50);comment:跳转路径" json:"redirect"`
 }
+
+// 用户账户信息
+type UserAuth struct {
+	Universal
+	UserInfoId    int       `gorm:"" json:"userInfoId"`
+	Username      string    `gorm:"type:varchar(50);comment:用户名" json:"username"`
+	Password      string    `gorm:"type:varchar(100)" json:"password"`
+	LoginType     int       `gorm:"type:tinyint(1);comment:登录类型" json:"loginType"`
+	IpAddress     string    `gorm:"type:varchar(20);comment:登录IP地址" json:"ipAddress"`
+	IpSource      string    `gorm:"type:varchar(50);comment:IP来源" json:"ip_source"`
+	LastLoginTime time.Time `gorm:"comment:上次登录时间" json:"LastLoginTime"`
+}
diff --git a/model/vo/user.go b/model/vo/user.go
@@ -0,0 +1,13 @@
+package vo
+
+import "time"
+
+// 登录VO
+type LoginVO struct {
+	ID            int       `json:"id"`
+	UserInfoId    int       `json:"userInfoId"`
+	Username      string    `json:"username"`
+	LastLoginTime time.Time `json:"last_login_time"`
+	LoginType     int       `json:"login_type"`
+	Token         string    `json:"token"`
+}
diff --git a/service/user.go b/service/user.go
@@ -0,0 +1,46 @@
+package service
+
+import (
+	"github.com/gin-gonic/gin"
+	"time"
+	"wow-admin/dao"
+	"wow-admin/model"
+	"wow-admin/model/dto"
+	"wow-admin/model/vo"
+	"wow-admin/utils"
+	"wow-admin/utils/result"
+)
+
+type UserService struct {
+}
+
+// 后台用户登录
+func (s *UserService) Login(c *gin.Context, username string, password string) (loginVO vo.LoginVO, code int) {
+	userAuth := dao.GetOne(model.UserAuth{}, "username", username)
+	if userAuth.ID == 0 {
+		return loginVO, result.ERROR_USER_NOT_EXIST
+	}
+
+	return loginVO, code
+}
+
+// 注册用户
+func (s *UserService) Register(userDto dto.Register) (code int) {
+
+	if exist := checkUserExistByUsername(userDto.Username); exist {
+		return result.ERROR_USER_NAME_USED
+	}
+
+	dao.Create(&model.UserAuth{
+		Username:      userDto.Username,
+		Password:      utils.Encryptor.BcryptHash(userDto.Password),
+		LoginType:     1,
+		LastLoginTime: time.Now(),
+	})
+	return result.OK
+}
+
+func checkUserExistByUsername(username string) bool {
+	user := dao.GetOne(model.UserAuth{}, "username = ?", username)
+	return user.ID != 0
+}
diff --git a/utils/encrypt.go b/utils/encrypt.go
@@ -0,0 +1,64 @@
+package utils
+
+import (
+	"crypto/md5"
+	"encoding/base64"
+	"encoding/hex"
+	"fmt"
+	"golang.org/x/crypto/bcrypt"
+	"golang.org/x/crypto/scrypt"
+	"log"
+	"math/rand"
+	"time"
+)
+
+type _encrypt struct{}
+
+var Encryptor = new(_encrypt)
+
+// 使用 scrypt 对密码进行加密生成一个哈希值
+func (*_encrypt) ScryptHash(password string) string {
+	const KeyLen = 10
+	// 随便写
+	salt := []byte{13, 14, 5, 2, 0, 55, 22, 11}
+
+	hashPwd, err := scrypt.Key([]byte(password), salt, 1<<15, 8, 1, KeyLen)
+	if err != nil {
+		log.Fatal("加密失败: ", err)
+	}
+	return base64.StdEncoding.EncodeToString(hashPwd)
+}
+
+// 使用 scrypt 对比 明文密码 和 数据库中哈希值
+func (c *_encrypt) ScryptCheck(password, hash string) bool {
+	return c.ScryptHash(password) == hash
+}
+
+// 使用 bcrypt 对密码进行加密生成一个哈希值
+func (*_encrypt) BcryptHash(password string) string {
+	bytes, _ := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
+	return string(bytes)
+}
+
+// 使用 bcrypt 对比 明文密码 和 数据库中哈希值
+func (*_encrypt) BcryptCheck(password, hash string) bool {
+	err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
+	return err == nil
+}
+
+// MD5 加密
+func (*_encrypt) MD5(str string, b ...byte) string {
+	h := md5.New()
+	h.Write([]byte(str))
+	return hex.EncodeToString(h.Sum(b))
+}
+
+// 验证码
+func (*_encrypt) ValidateCode() string {
+	return fmt.Sprintf("%06v", rand.New(rand.NewSource(time.Now().UnixNano())).Int31n(1000000))
+}
+
+// TODO
+func UUID() string {
+	return ""
+}
diff --git a/utils/gin_context.go b/utils/gin_context.go
@@ -0,0 +1,36 @@
+package utils
+
+import (
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+	"net/http"
+	"wow-admin/utils/result"
+)
+
+// 参数合法性校验
+func Validate(c *gin.Context, data any) {
+	validMsg := Validator.Validate(data)
+	if validMsg != "" {
+		result.ReturnJSON(c, http.StatusOK, result.ERROR_INVALID_PARAM, validMsg, nil)
+		panic(nil)
+	}
+}
+
+// Json 绑定
+func BindJson[T any](c *gin.Context) (data T) {
+	if err := c.ShouldBindJSON(&data); err != nil {
+		Logger.Error("ShouldBindJSON", zap.Error(err))
+		panic(result.ERROR_REQUEST_PARAM)
+	}
+	return
+}
+
+// Json 绑定验证 + 合法性校验
+func BindValidJson[T any](c *gin.Context) (data T) {
+	if err := c.ShouldBindJSON(&data); err != nil {
+		Logger.Error("ShouldBindJSON", zap.Error(err))
+		panic(result.ERROR_REQUEST_PARAM)
+	}
+	Validate(c, &data)
+	return data
+}
diff --git a/utils/gorms.go b/utils/gorms.go
@@ -29,6 +29,8 @@ func InitMyQLDB() *gorm.DB {
 
 	log.Println("MySQL 连接成功")
 
+	// _ = db.AutoMigrate(&model.UserAuth{})
+
 	sqlDB, _ := db.DB()
 
 	// 设置连接池中的最大闲置连接
diff --git a/utils/validator.go b/utils/validator.go
@@ -0,0 +1,53 @@
+package utils
+
+import (
+	"github.com/go-playground/locales/zh_Hans_CN"
+	unTrans "github.com/go-playground/universal-translator"
+	"github.com/go-playground/validator/v10"
+	zhTrans "github.com/go-playground/validator/v10/translations/zh"
+	"reflect"
+)
+
+type ValidateUtil struct {
+}
+
+var Validator = new(ValidateUtil)
+
+var (
+	uni      *unTrans.UniversalTranslator
+	validate *validator.Validate
+)
+
+func (v *ValidateUtil) Validate(data any) string {
+	// 实例化验证对象
+	validate = validator.New()
+
+	// 翻译器
+	trans := v.validateTransInit(validate)
+
+	err := validate.Struct(data)
+	if err != nil {
+		for _, e := range err.(validator.ValidationErrors) {
+			return e.Translate(trans)
+		}
+	}
+
+	return ""
+}
+
+// 数据验证翻译器
+func (*ValidateUtil) validateTransInit(validate *validator.Validate) unTrans.Translator {
+	// 万能翻译器，保存所有的语言环境和翻译数据
+	uni = unTrans.New(zh_Hans_CN.New())
+	// 翻译器
+	trans, _ := uni.GetTranslator("zh_Hans_CN")
+	//验证器注册翻译器
+	zhTrans.RegisterDefaultTranslations(validate, trans)
+
+	// 读取 Tag 中的 label 标签为字段的翻译
+	validate.RegisterTagNameFunc(func(field reflect.StructField) string {
+		return field.Tag.Get("label")
+	})
+
+	return trans
+}

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,6 @@ package dao`
`2`	`2`
`3`	`3`	`import (`
`4`	`4`	`"errors"`
`5`		`-`
`6`	`5`	`"gorm.io/gorm"`
`7`	`6`	`)`
`8`	`7`