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/validators"
	"golang.org/x/crypto/bcrypt"
)

//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 LoginUser(c *gin.Context, email, password string) *Token {
	var user database.User
	db := database.Connector()
	validate := validators.Validate
	if err := db.Where("email = ?", email).First(&user).Error; err != nil {
		return nil
	}
	if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(password)); err != nil {
		return nil
	}
	token := &Token{
		UserID: user.ID,
		Token:  generateToken(),
	}
	if err := db.Create(token).Error; err != nil {
		return nil
	}
	return token
}

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 EditUser(c *gin.Context, token string, user database.User) {
	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 string) {
	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)
}