refactored user service for new model repo style

go-backend/internal/services/user_service.go

@@ -8,51 +8,74 @@ import (
 	"GoMembership/internal/repositories"
 	"GoMembership/pkg/errors"
 
+	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
 
 	"time"
 )
 
 type UserServiceInterface interface {
-	RegisterUser(user *models.User) (id uint, token string, err error)
+	Register(user *models.User) (id uint, token string, err error)
-	GetUserByEmail(email string) (*models.User, error)
+	Update(user *models.User) (*models.User, error)
-	GetUserByID(id uint) (*models.User, error)
+	Delete(id *uint) error
+	FromContext(c *gin.Context) (*models.User, error)
+	FromID(id *uint) (*models.User, error)
+	FromEmail(email *string) (*models.User, error)
 	GetUsers(where map[string]interface{}) (*[]models.User, error)
-	UpdateUser(user *models.User) (*models.User, error)
-	DeleteUser(lastname string, id uint) error
-	SetUserStatus(id uint, status uint) error
-	VerifyUser(token *string, verificationType *string) (*models.Verification, error)
-	SetVerificationToken(id *uint, verificationType *string) (string, error)
-	RevokeVerification(id *uint, verificationType string) error
-	HandlePasswordChangeRequest(user *models.User) (token string, err error)
 }
 
 type UserService struct {
-	Repo     repositories.UserRepositoryInterface
 	Licences repositories.LicenceInterface
+	DB       *gorm.DB
 }
 
-func (service *UserService) DeleteUser(lastname string, id uint) error {
+func (s *UserService) FromContext(c *gin.Context) (*models.User, error) {
-	if id == 0 || lastname == "" {
+	var user models.User
-		return errors.ErrNoData
+	if err := user.FromContext(s.DB, c); err != nil {
+		return nil, err
 	}
+	return &user, nil
+}
 
-	user, err := service.GetUserByID(id)
+func (s *UserService) FromID(id *uint) (*models.User, error) {
-	if err != nil {
+	var user models.User
+	if err := user.FromID(s.DB, id); err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+func (s *UserService) FromEmail(email *string) (*models.User, error) {
+	var user models.User
+	if err := user.FromEmail(s.DB, email); err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+func (s *UserService) Delete(id *uint) error {
+	var user models.User
+	if err := user.FromID(s.DB, id); err != nil {
 		return err
 	}
-	if user == nil {
-		return errors.ErrUserNotFound
-	}
 
-	return service.Repo.DeleteUser(id)
+	return user.Delete(s.DB)
 }
 
-func (service *UserService) UpdateUser(user *models.User) (*models.User, error) {
+func (s *UserService) Update(user *models.User) (*models.User, error) {
 
-	if user.ID == 0 {
+	var existingUser models.User
-		return nil, errors.ErrUserNotFound
+	if err := existingUser.FromID(s.DB, &user.ID); err != nil {
+		return nil, err
 	}
+	user.MembershipID = existingUser.MembershipID
+	user.Membership.ID = existingUser.Membership.ID
+	if existingUser.Licence != nil {
+		user.Licence.ID = existingUser.Licence.ID
+		user.LicenceID = existingUser.LicenceID
+	}
+	user.BankAccount.ID = existingUser.BankAccount.ID
+	user.BankAccountID = existingUser.BankAccountID
 
 	user.SetPassword(user.Password)
 
@@ -64,9 +87,7 @@ func (service *UserService) UpdateUser(user *models.User) (*models.User, error)
 	user.Membership.SubscriptionModel = *selectedModel
 	user.Membership.SubscriptionModelID = selectedModel.ID
 
-	updatedUser, err := service.Repo.UpdateUser(user)
+	if err := user.Update(s.DB); err != nil {
-
-	if err != nil {
 		if err == gorm.ErrRecordNotFound {
 			return nil, errors.ErrUserNotFound
 		}
@@ -75,42 +96,38 @@ func (service *UserService) UpdateUser(user *models.User) (*models.User, error)
 		}
 		return nil, err
 	}
-
+	return user, nil
-	return updatedUser, nil
 }
 
-func (service *UserService) RegisterUser(user *models.User) (id uint, token string, err error) {
+func (s *UserService) Register(user *models.User) (id uint, token string, err error) {
-
 	user.SetPassword(user.Password)
 
+	selectedModel, err := repositories.GetSubscriptionByName(&user.Membership.SubscriptionModel.Name)
+	if err != nil {
+		return 0, "", errors.ErrSubscriptionNotFound
+	}
+	user.Membership.SubscriptionModel = *selectedModel
+	user.Membership.SubscriptionModelID = selectedModel.ID
 	user.Status = constants.UnverifiedStatus
-	user.CreatedAt = time.Now()
-	user.UpdatedAt = time.Now()
 	user.PaymentStatus = constants.AwaitingPaymentStatus
 	user.BankAccount.MandateDateSigned = time.Now()
-	id, err = service.Repo.CreateUser(user)
+	v, err := user.SetVerification(constants.VerificationTypes.Email)
 	if err != nil {
 		return 0, "", err
 	}
 
-	token, err = service.SetVerificationToken(&id, &constants.VerificationTypes.Email)
+	if err := user.Create(s.DB); err != nil {
-	if err != nil {
 		return 0, "", err
 	}
-	return id, token, nil
+
+	return user.ID, v.VerificationToken, nil
 }
 
-func (service *UserService) GetUserByID(id uint) (*models.User, error) {
+// GetUsers returns a list of users based on the provided where clause.
-	return repositories.GetUserByID(&id)
+// if where == nil: all users are returned
-}
+func (s *UserService) GetUsers(where map[string]interface{}) (*[]models.User, error) {
-
-func (service *UserService) GetUserByEmail(email string) (*models.User, error) {
-	return service.Repo.GetUserByEmail(email)
-}
-
-func (service *UserService) GetUsers(where map[string]interface{}) (*[]models.User, error) {
 	if where == nil {
 		where = map[string]interface{}{}
 	}
-	return service.Repo.GetUsers(where)
+	return models.GetUsersWhere(s.DB, where)
 }