apifiber/controllers/authController.go

package controllers

import (
	"api/config"
	"api/database"
	"api/models"
	"api/utils"
	"log"
	"strconv"
	"strings"
	"time"

	"github.com/gofiber/fiber/v2"
	"github.com/golang-jwt/jwt/v5"
	"golang.org/x/crypto/bcrypt"
)

// MARK: Login
func Login(c *fiber.Ctx) error {

	var data map[string]string

	if err := c.BodyParser(&data); err != nil {
		log.Printf("Bad Request on parse: %v\n", err)
		return fiber.ErrBadRequest
	}

	var user models.User

	database.DB.Where("email = ?", data["email"]).First(&user)

	if user.ID == 0 {
		return c.JSON(fiber.Map{
			"message": "Usuário não encontrado",
			"token":   ""})
	}

	if user.Password == nil {
		return c.JSON(fiber.Map{
			"message": "Usuário com cadastro imcompleto",
			"token":   ""})
	}

	if err := bcrypt.CompareHashAndPassword(user.Password, []byte(data["password"])); err != nil {
		return c.JSON(fiber.Map{
			"message": "Senha inválida",
			"token":   ""})
	}

	if user.Blocked == "S" {
		return c.JSON(fiber.Map{
			"message": "Usuário bloqueado",
			"token":   ""})
	}

	claims := &jwt.RegisteredClaims{
		ExpiresAt: &jwt.NumericDate{Time: time.Now().Add(12 * time.Hour)}, // Token expiration time
		Issuer:    strconv.Itoa(int(user.ID)),                             // User that creates the token
	}

	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)

	tk, err := token.SignedString([]byte(config.Conf.ApiSecret))

	if err != nil {
		return fiber.ErrInternalServerError
	}

	return c.JSON(fiber.Map{
		"message": "",
		"uid":     user.ID,
		"token":   tk})
}

// MARK: AddUser
func AddUser(c *fiber.Ctx) error {

	var data map[string]string

	if err := c.BodyParser(&data); err != nil {
		return c.JSON(fiber.Map{
			"message": "Dados inválidos"})

	}

	if data["name"] == "" || data["email"] == "" || data["url"] == "" || data["cpfcnpj"] == "" || data["password"] == "" || data["channel"] == "" || data["usertype"] == "" || data["companyname"] == "" {
		return c.JSON(fiber.Map{
			"message": "Dados inválidos"})
	}

	passwd, _ := utils.HashPassword(data["password"])

	var user models.User

	database.DB.Where("email = ?", data["email"]).First(&user)

	if user.ID != 0 {
		return c.JSON(fiber.Map{
			"message": "Usuário já cadastrado"})
	}

	database.DB.Where("channel = ?", strings.ToLower(data["channel"])).First(&user)

	if user.ID != 0 {
		return c.JSON(fiber.Map{
			"message": "Canal já em uso"})
	}

	user = models.User{
		Name:        data["name"],
		Email:       data["email"],
		CompanyName: data["companyname"],
		Url:         data["url"],
		Password:    passwd,
		Channel:     strings.ToLower(data["channel"]),
		CpfCnpj:     data["cpfcnpj"],
		UserType:    data["usertype"],
		Blocked:     "N",
		Cancelled:   "N",
	}

	database.DB.Create(&user)

	if user.ID == 0 {
		return c.JSON(fiber.Map{
			"message": "Erro ao criar usuário"})
	}

	return c.JSON(user)
}

// MARK: GetOwnUser
func GetOwnUser(c *fiber.Ctx) error {

	user := c.Locals("user").(models.User)

	return c.JSON(user)
}

// MARK: GetAllUsers
func GetAllUsers(c *fiber.Ctx) error {

	var users []models.User

	user := c.Locals("user").(models.User)

	if user.UserType != "A" {
		return fiber.ErrUnauthorized
	}

	database.DB.Find(&users)

	// if len(users) == 0 {
	// 	return fiber.ErrNotFound
	// }

	return c.JSON(users)
}

// MARK: GetUserByEmail
func GetUserByEmail(c *fiber.Ctx) error {

	user := c.Locals("user").(models.User)

	if user.UserType != "A" {
		return fiber.ErrUnauthorized
	}

	email := c.Params("email")

	database.DB.Where("email = ?", email).First(&user)

	// if user.ID == 0 {
	// 	return fiber.ErrNotFound
	// }

	return c.JSON(user)
}

func CreateUser(c *fiber.Ctx) error {

	type CreateUser struct {
		Email string `json:"email"`
		Type  string `json:"type"`
	}

	var u CreateUser

	if err := c.BodyParser(&u); err != nil {
		return fiber.ErrBadRequest
	}

	user := models.User{
		Email:    u.Email,
		UserType: u.Type,
	}

	database.DB.Create(&user)

	return c.JSON(user)
}

// MARK: Checkuser
func Checkuser(c *fiber.Ctx) error {

	type Checkuser struct {
		Email string `json:"email"`
		Type  string `json:"type"`
	}

	var user models.User
	var response Checkuser

	email := c.Params("email")

	response.Email = email

	// Check if user exists
	database.DB.Where("email = ?", email).First(&user)

	if user.ID == 0 {
		// The user is not found, so it's an eligible tester; let's signalize this
		response.Type = "T"
	} else {
		// The user is found and it's an admin; let's signalize this
		if user.UserType == "A" {
			response.Type = "A"
		}

		// The user is found and it's a pay user; let's signalize this
		if user.UserType == "U" {
			// If the user doesn't have a channel, it's a pay user that needs to complete the registration
			if len(user.Channel) == 0 {
				response.Type = "RU"
			} else {
				response.Type = "U"
			}
		}

		// The user is found and it's a social; let's signalize this
		if user.UserType == "S" {
			// If the user doesn't have a channel, it's a social user that needs to complete the registration
			if len(user.Channel) == 0 {
				response.Type = "RS"
			} else {
				response.Type = "S"
			}
		}

		if user.Blocked == "S" {
			// User is blocked
			response.Type = "UB"
		} else {
			if user.Cancelled == "S" {
				// User is cancelled
				response.Type = "UC"
			}
		}
	}

	// TODO: Should we insert the user in the database, if it's a tester?

	return c.JSON(response)
}