130 lines
3.5 KiB
Go
130 lines
3.5 KiB
Go
package services
|
|
|
|
import (
|
|
"net/http"
|
|
"strings"
|
|
|
|
"github.com/go-playground/validator/v10"
|
|
|
|
"GoMembership/internal/constants"
|
|
"GoMembership/internal/models"
|
|
"GoMembership/internal/repositories"
|
|
"GoMembership/internal/utils"
|
|
"GoMembership/pkg/logger"
|
|
|
|
"time"
|
|
)
|
|
|
|
type UserServiceInterface interface {
|
|
RegisterUser(user *models.User) (int64, string, error)
|
|
FindUserByEmail(email string) (*models.User, error)
|
|
GetUsers(where map[string]interface{}) (*[]models.User, error)
|
|
// AuthenticateUser(email, password string) (*models.User, error)A
|
|
VerifyUser(token *string) (*models.User, error)
|
|
}
|
|
|
|
type UserService struct {
|
|
Repo repositories.UserRepositoryInterface
|
|
}
|
|
|
|
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)
|
|
*/
|
|
err := validateRegistrationData(user)
|
|
if err != nil {
|
|
return http.StatusNotAcceptable, "", err
|
|
}
|
|
|
|
user.Status = constants.UnverifiedStatus
|
|
user.CreatedAt = time.Now()
|
|
user.UpdatedAt = time.Now()
|
|
|
|
id, err := service.Repo.CreateUser(user)
|
|
|
|
if err != nil && strings.Contains(err.Error(), "UNIQUE constraint failed") {
|
|
return http.StatusConflict, "", err
|
|
} else if err != nil {
|
|
return http.StatusInternalServerError, "", err
|
|
}
|
|
|
|
user.ID = id
|
|
|
|
token, err := utils.GenerateVerificationToken()
|
|
if err != nil {
|
|
return http.StatusInternalServerError, "", err
|
|
}
|
|
|
|
logger.Info.Printf("TOKEN: %v", token)
|
|
|
|
_, err = service.Repo.SetVerificationToken(user, &token)
|
|
if err != nil {
|
|
return http.StatusInternalServerError, "", err
|
|
}
|
|
|
|
return id, token, nil
|
|
}
|
|
|
|
func (service *UserService) FindUserByEmail(email string) (*models.User, error) {
|
|
return service.Repo.FindUserByEmail(email)
|
|
}
|
|
|
|
func (service *UserService) GetUsers(where map[string]interface{}) (*[]models.User, error) {
|
|
return service.Repo.GetUsers(where)
|
|
}
|
|
|
|
func (service *UserService) VerifyUser(token *string) (*models.User, error) {
|
|
user, err := service.Repo.VerifyUserOfToken(token)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return user, nil
|
|
}
|
|
|
|
func validateRegistrationData(user *models.User) error {
|
|
validate := validator.New()
|
|
validate.RegisterValidation("age", utils.AgeValidator)
|
|
validate.RegisterValidation("bic", utils.BICValidator)
|
|
validate.RegisterValidation("iban", utils.IBANValidator)
|
|
validate.RegisterValidation("subscriptionModel", utils.SubscriptionModelValidator)
|
|
validate.RegisterValidation("membershipField", utils.ValidateRequiredMembershipField)
|
|
return validate.Struct(user)
|
|
}
|
|
|
|
/* 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
|
|
} */
|