Go-TestAPI/controllers/userController.go

package controllers

// Пример генератора токена

import (
	"crypto/rand"
	"encoding/base64"
	"github.com/gin-gonic/gin"
	"github.com/go-playground/validator/v10"
	"golang-test/database"
	"golang-test/libs"
	"golang-test/message"
	"golang-test/types"
	"golang-test/validators"
	"golang.org/x/crypto/bcrypt"
	"strings"
)

//func tokenGenerator() string {
//	b := make([]byte, 4)
//	rand.Read(b)
//	return fmt.Sprintf("%x", b)
//}

//	func main() {
//		a := tokenGenerator()
//		fmt.Println(a)
//	}

type TokenStruct struct {
	UserID uint
	token  string
}

//func RegisterUser(c *gin.Context, user database.User) {
//	db := database.Connector()
//	validate := validators.Validate
//	response := message.Response{Status: 200}
//	if err := validate.Struct(user); err != nil {
//		response.Error = libs.GetValidationErrors(err.(validator.ValidationErrors))
//		response.Status = 400
//		message.SendResponse(c, response)
//		return
//	}
//	hash, err := bcrypt.GenerateFromPassword([]byte(user.Password), 12)
//	if err != nil {
//		return
//	}
//	user.Password = string(hash)
//	if err := db.Create(user).Error; err != nil {
//		return
//	}
//	return
//}

func RegisterUser(c *gin.Context, register database.User) {
	var user database.User
	db := database.Connector()
	validate := validators.Validate
	response := message.Response{Status: 201}
	var token *database.Token

	if err := validate.Struct(register); err != nil {
		response.Error = libs.GetValidationErrors(err.(validator.ValidationErrors))
		response.Status = 400
		message.SendResponse(c, response)
		return
	}

	if err := db.Where("email =?", register.Email).First(&user).Error; err == nil {
		response.Status = 400
		response.Error = gin.H{
			"error": "User already exists",
		}
		message.SendResponse(c, response)
		return
	}

	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(register.Password), 12)
	if err != nil {
		response.Status = 500
		response.Error = gin.H{
			"error": "Internal Server Error",
		}
		message.SendResponse(c, response)
		return
	}

	user.Email = register.Email
	user.Password = string(hashedPassword)
	user.Name = register.Name

	if err := db.Create(&user).Error; err != nil {
		response.Status = 500
		response.Error = gin.H{
			"error": "Internal Server Error",
		}
		message.SendResponse(c, response)
		return
	}

	token.Token = generateToken()
	token.UserID = user.ID
	user.Tokens = append(user.Tokens, token)

	response.Message = gin.H{
		"message": "Registration Success",
	}

	message.SendResponse(c, response)
}

func LoginUser(c *gin.Context, login types.LoginRequest) {
	var user database.User
	db := database.Connector()
	validate := validators.Validate
	response := message.Response{Status: 200}
	var token *database.Token

	if err := validate.Struct(login); err != nil {
		response.Error = libs.GetValidationErrors(err.(validator.ValidationErrors))
		response.Status = 400
		message.SendResponse(c, response)
		return
	}
	if err := db.Where("email = ?", login.Email).First(&user).Error; err != nil {
		response.Status = 404
		response.Error = gin.H{
			"error": "User not found",
		}
	}

	if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(login.Password)); err != nil {
		response.Status = 404
		response.Error = gin.H{
			"error": "User not found",
		}
	}

	token.Token = generateToken()
	token.UserID = user.ID
	user.Tokens = append(user.Tokens, token)

	response.Message = gin.H{
		"message": "Login Success",
	}

	message.SendResponse(c, response)
}

func generateToken() string {
	b := make([]byte, 4)
	if _, err := rand.Read(b); err != nil {
		return ""
	}
	return base64.StdEncoding.EncodeToString(b)
}

func GetUserByToken(token string) (database.User, error) {
	var tokenObject TokenStruct
	var err error
	var user database.User

	db := database.Connector()
	if err := db.Where("token = ?", token).First(&tokenObject).Error; err != nil {
		return user, err
	}
	if err := db.First(&user, tokenObject.UserID).Error; err != nil {
		return user, err
	}
	return user, err
}

func GetUser(c *gin.Context, user database.User) {
	token := strings.Split(c.Request.Header["Bearer"][0], " ")[1]
	validate := validators.Validate
	response := message.Response{Status: 200}
	u, err := GetUserByToken(token)
	if err != nil {
		response.Status = 401
		response.Error = gin.H{
			"error": "Token is invalid, please login",
		}
		message.SendResponse(c, response)
		return
	}

	if err := validate.Struct(user); err != nil {
		response.Error = libs.GetValidationErrors(err.(validator.ValidationErrors))
		response.Status = 400
		message.SendResponse(c, response)
		return
	}

	response.Message = gin.H{
		"message": "User data successfully received",
		"user":    u,
	}
	message.SendResponse(c, response)
}

func EditUser(c *gin.Context, user database.User) {
	token := strings.Split(c.Request.Header["Bearer"][0], " ")[1]

	db := database.Connector()
	validate := validators.Validate
	response := message.Response{Status: 200}
	u, err := GetUserByToken(token)
	if err != nil {
		response.Status = 401
		response.Error = gin.H{
			"error": "Token is invalid, please login",
		}
		message.SendResponse(c, response)
		return
	}

	if err := validate.Struct(user); err != nil {
		response.Error = libs.GetValidationErrors(err.(validator.ValidationErrors))
		response.Status = 400
		message.SendResponse(c, response)
		return
	}

	hash, err := bcrypt.GenerateFromPassword([]byte(user.Password), 12)
	if err != nil {
		response.Status = 500
		response.Error = gin.H{
			"error": err,
		}
		message.SendResponse(c, response)
		return
	}

	u.Password = string(hash)

	if err := db.Save(u).Error; err != nil {
		response.Status = 500
		response.Error = gin.H{
			"error": err,
		}
		message.SendResponse(c, response)
		return
	}

	response.Message = gin.H{
		"message": "User successfully updated",
	}
	message.SendResponse(c, response)
}

func DeleteUser(c *gin.Context) {
	token := strings.Split(c.Request.Header["Bearer"][0], " ")[1]
	db := database.Connector()
	u, err := GetUserByToken(token)
	response := message.Response{Status: 200}
	if err != nil {
		response.Status = 401
		response.Error = gin.H{
			"error": "Token is invalid, please login",
		}
		message.SendResponse(c, response)
		return
	}

	if err := db.Delete(u).Error; err != nil {
		response.Status = 500
		response.Error = gin.H{
			"error": err,
		}
		message.SendResponse(c, response)
		return
	}

	response.Message = gin.H{
		"message": "User successfully deleted",
	}
	message.SendResponse(c, response)
}