109 lines
2.7 KiB
Go
109 lines
2.7 KiB
Go
package services
|
|
|
|
import (
|
|
"GoMembership/internal/constants"
|
|
"GoMembership/internal/models"
|
|
"GoMembership/internal/repositories"
|
|
"GoMembership/internal/utils"
|
|
"GoMembership/pkg/logger"
|
|
|
|
// "crypto/rand"
|
|
// "encoding/base64"
|
|
// "golang.org/x/crypto/bcrypt"
|
|
"time"
|
|
)
|
|
|
|
type UserService interface {
|
|
RegisterUser(user *models.User) (int64, string, error)
|
|
// AuthenticateUser(email, password string) (*models.User, error)A
|
|
VerifyUser(token *string) (*models.User, error)
|
|
}
|
|
|
|
type userService struct {
|
|
repo repositories.UserRepository
|
|
}
|
|
|
|
func NewUserService(repo repositories.UserRepository) UserService {
|
|
return &userService{repo}
|
|
}
|
|
|
|
func (service *userService) RegisterUser(user *models.User) (int64, string, error) {
|
|
/* salt := make([]byte, 16)
|
|
if _, err := rand.Read(salt); err != nil {
|
|
return -1, err
|
|
}
|
|
user.Salt = base64.StdEncoding.EncodeToString(salt)
|
|
|
|
hashedPassword, err := HashPassword(user.Password, user.Salt)
|
|
if err != nil {
|
|
return -1, err
|
|
}
|
|
user.Password = string(hashedPassword) */
|
|
user.Status = constants.UnverifiedStatus
|
|
user.CreatedAt = time.Now()
|
|
user.UpdatedAt = time.Now()
|
|
id, err := service.repo.CreateUser(user)
|
|
if err != nil {
|
|
return -1, "", err
|
|
}
|
|
user.ID = id
|
|
|
|
token, err := utils.GenerateVerificationToken()
|
|
if err != nil {
|
|
return -1, "", err
|
|
}
|
|
|
|
logger.Info.Printf("user: %+v", user)
|
|
_, err = service.repo.SetVerificationToken(user, &token)
|
|
if err != nil {
|
|
return -1, "", err
|
|
}
|
|
return id, token, nil
|
|
}
|
|
|
|
func (service *userService) VerifyUser(token *string) (*models.User, error) {
|
|
userID, err := service.repo.VerifyUserOfToken(token)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
user, err := service.repo.FindUserByID(userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return user, nil
|
|
}
|
|
|
|
/* func HashPassword(password string, salt string) (string, error) {
|
|
saltedPassword := password + salt
|
|
hashedPassword, err := bcrypt.GenerateFromPassword([]byte(saltedPassword), bcrypt.DefaultCost)
|
|
if err != nil {
|
|
|
|
return "", err
|
|
}
|
|
return base64.StdEncoding.EncodeToString(hashedPassword), nil
|
|
} */
|
|
|
|
/* func (s *userService) AuthenticateUser(email, password string) (*models.User, error) {
|
|
user, err := s.repo.FindUserByEmail(email)
|
|
if err != nil {
|
|
return nil, errors.ErrUserNotFound
|
|
}
|
|
|
|
if !verifyPassword(password, user.Password, user.Salt) {
|
|
return nil, errors.ErrInvalidCredentials
|
|
}
|
|
|
|
return user, nil
|
|
}
|
|
*/
|
|
/* func verifyPassword(password string, storedPassword string, salt string) bool {
|
|
|
|
saltedPassword := password + salt
|
|
decodedStoredPassword, err := base64.StdEncoding.DecodeString(storedPassword)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
err = bcrypt.CompareHashAndPassword([]byte(decodedStoredPassword), []byte(saltedPassword))
|
|
return err == nil
|
|
} */
|