diff --git a/go-backend/internal/controllers/membershipController.go b/go-backend/internal/controllers/membershipController.go
index 36a4f98..a4cafe6 100644
--- a/go-backend/internal/controllers/membershipController.go
+++ b/go-backend/internal/controllers/membershipController.go
@@ -16,10 +16,8 @@ import (
 )
 
 type MembershipController struct {
-	Service        services.MembershipService
-	UserController interface {
-		ExtractUserFromContext(*gin.Context) (*models.User, error)
-	}
+	Service     services.MembershipServiceInterface
+	UserService services.UserServiceInterface
 }
 
 type MembershipData struct {
@@ -30,14 +28,14 @@ type MembershipData struct {
 func (mc *MembershipController) RegisterSubscription(c *gin.Context) {
 	var regData MembershipData
 
-	requestUser, err := mc.UserController.ExtractUserFromContext(c)
+	requestUser, err := mc.UserService.FromContext(c)
 	if err != nil {
 		utils.RespondWithError(c, err, "Error extracting user from context in subscription registrationHandler", http.StatusBadRequest, errors.Responses.Fields.User, errors.Responses.Keys.NoAuthToken)
 		return
 	}
 
-	if !utils.HasPrivilige(requestUser, constants.Priviliges.Create) {
-		utils.RespondWithError(c, errors.ErrNotAuthorized, "Not allowed to register subscription", http.StatusForbidden, errors.Responses.Fields.User, errors.Responses.Keys.Unauthorized)
+	if !requestUser.HasPrivilege(constants.Priviliges.Create) {
+		utils.RespondWithError(c, errors.ErrNotAuthorized, "Not allowed to register subscription", http.StatusUnauthorized, errors.Responses.Fields.User, errors.Responses.Keys.Unauthorized)
 		return
 	}
 
@@ -66,14 +64,14 @@ func (mc *MembershipController) RegisterSubscription(c *gin.Context) {
 func (mc *MembershipController) UpdateHandler(c *gin.Context) {
 	var regData MembershipData
 
-	requestUser, err := mc.UserController.ExtractUserFromContext(c)
+	requestUser, err := mc.UserService.FromContext(c)
 	if err != nil {
 		utils.RespondWithError(c, err, "Error extracting user from context in subscription Updatehandler", http.StatusBadRequest, errors.Responses.Fields.User, errors.Responses.Keys.NoAuthToken)
 		return
 	}
 
-	if !utils.HasPrivilige(requestUser, constants.Priviliges.Update) {
-		utils.RespondWithError(c, errors.ErrNotAuthorized, "Not allowed to update subscription", http.StatusForbidden, errors.Responses.Fields.User, errors.Responses.Keys.Unauthorized)
+	if !requestUser.HasPrivilege(constants.Priviliges.Update) {
+		utils.RespondWithError(c, errors.ErrNotAuthorized, "Not allowed to update subscription", http.StatusUnauthorized, errors.Responses.Fields.User, errors.Responses.Keys.Unauthorized)
 		return
 	}
 
@@ -105,14 +103,14 @@ func (mc *MembershipController) DeleteSubscription(c *gin.Context) {
 	}
 
 	var data deleteData
-	requestUser, err := mc.UserController.ExtractUserFromContext(c)
+	requestUser, err := mc.UserService.FromContext(c)
 	if err != nil {
 		utils.RespondWithError(c, err, "Error extracting user from context in subscription deleteSubscription", http.StatusBadRequest, errors.Responses.Fields.User, errors.Responses.Keys.NoAuthToken)
 		return
 	}
 
-	if !utils.HasPrivilige(requestUser, constants.Priviliges.Delete) {
-		utils.RespondWithError(c, errors.ErrNotAuthorized, "Not allowed to update subscription", http.StatusForbidden, errors.Responses.Fields.User, errors.Responses.Keys.Unauthorized)
+	if !requestUser.HasPrivilege(constants.Priviliges.Delete) {
+		utils.RespondWithError(c, errors.ErrNotAuthorized, "Not allowed to update subscription", http.StatusUnauthorized, errors.Responses.Fields.User, errors.Responses.Keys.Unauthorized)
 		return
 	}
 
diff --git a/go-backend/internal/controllers/user_Password.go b/go-backend/internal/controllers/user_Password.go
index ddb9825..016471d 100644
--- a/go-backend/internal/controllers/user_Password.go
+++ b/go-backend/internal/controllers/user_Password.go
@@ -4,7 +4,6 @@ import (
 	"GoMembership/internal/constants"
 	"GoMembership/internal/utils"
 	"GoMembership/pkg/errors"
-	"fmt"
 	"net/http"
 	"strconv"
 
@@ -15,16 +14,15 @@ import (
 
 func (uc *UserController) CreatePasswordHandler(c *gin.Context) {
 
-	requestUser, err := uc.ExtractUserFromContext(c)
+	requestUser, err := uc.Service.FromContext(c)
 	if err != nil {
-		utils.RespondWithError(c, err, "Error extracting user from context in UpdateHandler", http.StatusBadRequest, errors.Responses.Fields.User, errors.Responses.Keys.NoAuthToken)
+		utils.RespondWithError(c, err, "Couldn't get User from Request Context", http.StatusBadRequest, errors.Responses.Fields.General, errors.Responses.Keys.NoAuthToken)
 		return
 	}
-	if !utils.HasPrivilige(requestUser, constants.Priviliges.AccessControl) {
-		utils.RespondWithError(c, errors.ErrNotAuthorized, fmt.Sprintf("Not allowed to handle other users. RoleID(%v)<Privilige(%v)", requestUser.RoleID, constants.Priviliges.View), http.StatusForbidden, errors.Responses.Fields.User, errors.Responses.Keys.Unauthorized)
+	if !requestUser.IsAdmin() {
+		utils.RespondWithError(c, errors.ErrNotAuthorized, "Requesting user not authorized to grant user access", http.StatusUnauthorized, errors.Responses.Fields.User, errors.Responses.Keys.Unauthorized)
 		return
 	}
-
 	// Expected data from the user
 	var input struct {
 		User struct {
@@ -38,21 +36,26 @@ func (uc *UserController) CreatePasswordHandler(c *gin.Context) {
 	}
 
 	// find user
-	db_user, err := uc.Service.GetUserByID(input.User.ID)
+	user, err := uc.Service.FromID(&input.User.ID)
 	if err != nil {
 		utils.RespondWithError(c, err, "couldn't get user by id", http.StatusNotFound, errors.Responses.Fields.User, errors.Responses.Keys.NotFound)
 		return
 	}
 
-	// create token
-	token, err := uc.Service.HandlePasswordChangeRequest(db_user)
+	// Deactivate user and reset Verification
+	user.Status = constants.DisabledStatus
+	v, err := user.SetVerification(constants.VerificationTypes.Password)
 	if err != nil {
-		utils.RespondWithError(c, err, "couldn't handle password change request", http.StatusInternalServerError, errors.Responses.Fields.General, errors.Responses.Keys.InternalServerError)
+		utils.RespondWithError(c, err, "couldn't set verification", http.StatusInternalServerError, errors.Responses.Fields.User, errors.Responses.Keys.InternalServerError)
 		return
 	}
 
+	if _, err := uc.Service.Update(user); err != nil {
+		utils.RespondWithError(c, err, "Couldn't update user in createPasswordHandler", http.StatusInternalServerError, errors.Responses.Fields.General, errors.Responses.Keys.InternalServerError)
+		return
+	}
 	// send email
-	if err := uc.EmailService.SendGrantBackendAccessEmail(db_user, &token); err != nil {
+	if err := uc.EmailService.SendGrantBackendAccessEmail(user, &v.VerificationToken); err != nil {
 		utils.RespondWithError(c, err, "Couldn't send grant backend access email", http.StatusInternalServerError, errors.Responses.Fields.General, errors.Responses.Keys.InternalServerError)
 		return
 	}
@@ -74,27 +77,30 @@ func (uc *UserController) RequestPasswordChangeHandler(c *gin.Context) {
 		return
 	}
 	// find user
-	db_user, err := uc.Service.GetUserByEmail(input.Email)
+	user, err := uc.Service.FromEmail(&input.Email)
 	if err != nil {
 		utils.RespondWithError(c, err, "couldn't get user by email", http.StatusNotFound, errors.Responses.Fields.User, errors.Responses.Keys.NotFound)
 		return
 	}
-
 	// check if user may change the password
-	if db_user.Status <= constants.DisabledStatus {
-		utils.RespondWithError(c, errors.ErrNotAuthorized, "User password change request denied, user is disabled", http.StatusForbidden, errors.Responses.Fields.Login, errors.Responses.Keys.UserDisabled)
+	if !user.IsVerified() {
+		utils.RespondWithError(c, errors.ErrNotAuthorized, "User password change request denied, user is not verified or disabled", http.StatusForbidden, errors.Responses.Fields.Login, errors.Responses.Keys.UserDisabled)
 		return
 	}
 
-	// create token
-	token, err := uc.Service.HandlePasswordChangeRequest(db_user)
+	user.Status = constants.DisabledStatus
+	v, err := user.SetVerification(constants.VerificationTypes.Password)
 	if err != nil {
-		utils.RespondWithError(c, err, "couldn't handle password change request", http.StatusInternalServerError, errors.Responses.Fields.General, errors.Responses.Keys.InternalServerError)
+		utils.RespondWithError(c, err, "couldn't set verification", http.StatusInternalServerError, errors.Responses.Fields.User, errors.Responses.Keys.InternalServerError)
 		return
 	}
 
+	if _, err := uc.Service.Update(user); err != nil {
+		utils.RespondWithError(c, err, "Couldn't update user in createPasswordHandler", http.StatusInternalServerError, errors.Responses.Fields.General, errors.Responses.Keys.InternalServerError)
+		return
+	}
 	// send email
-	if err := uc.EmailService.SendChangePasswordEmail(db_user, &token); err != nil {
+	if err := uc.EmailService.SendChangePasswordEmail(user, &v.VerificationToken); err != nil {
 		utils.RespondWithError(c, err, "Couldn't send change password email", http.StatusInternalServerError, errors.Responses.Fields.General, errors.Responses.Keys.InternalServerError)
 		return
 	}
@@ -115,27 +121,24 @@ func (uc *UserController) ChangePassword(c *gin.Context) {
 		utils.RespondWithError(c, err, "Invalid user ID", http.StatusBadRequest, errors.Responses.Fields.User, errors.Responses.Keys.InvalidUserID)
 		return
 	}
+	userID := uint(userIDint)
+	user, err := uc.Service.FromID(&userID)
+	if err != nil {
+		utils.RespondWithError(c, err, "Couldn't find user", http.StatusNotFound, errors.Responses.Fields.User, errors.Responses.Keys.UserNotFoundWrongPassword)
+		return
+	}
 
 	if err := c.ShouldBindJSON(&input); err != nil {
 		utils.HandleValidationError(c, err)
 		return
 	}
 
-	verification, err := uc.Service.VerifyUser(&input.Token, &constants.VerificationTypes.Password)
-	if err != nil || uint(userIDint) != verification.UserID {
-		utils.HandleVerifyUserError(c, err)
-		return
-	}
-
-	user, err := uc.Service.GetUserByID(verification.UserID)
-	if err != nil {
-		utils.RespondWithError(c, err, "Couldn't find user", http.StatusNotFound, errors.Responses.Fields.User, errors.Responses.Keys.UserNotFoundWrongPassword)
+	if !user.Verify(input.Token, constants.VerificationTypes.Password) {
+		utils.RespondWithError(c, errors.ErrAlreadyVerified, "Couldn't verify user", http.StatusInternalServerError, errors.Responses.Fields.General, errors.Responses.Keys.InternalServerError)
 		return
 	}
 
 	user.Status = constants.ActiveStatus
-	user.Verification = *verification
-	user.ID = verification.UserID
 	user.Password = input.Password
 
 	// Get Gin's binding validator engine with all registered validators
@@ -146,7 +149,7 @@ func (uc *UserController) ChangePassword(c *gin.Context) {
 		utils.HandleValidationError(c, err)
 		return
 	}
-	_, err = uc.Service.UpdateUser(user)
+	_, err = uc.Service.Update(user)
 	if err != nil {
 		utils.HandleUserUpdateError(c, err)
 		return
diff --git a/go-backend/internal/controllers/user_controller.go b/go-backend/internal/controllers/user_controller.go
index c7306b0..767c951 100644
--- a/go-backend/internal/controllers/user_controller.go
+++ b/go-backend/internal/controllers/user_controller.go
@@ -9,11 +9,14 @@ import (
 	"GoMembership/internal/utils"
 	"GoMembership/internal/validation"
 	"fmt"
+	"strconv"
 	"strings"
 
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"github.com/gin-gonic/gin/binding"
+	"github.com/go-playground/validator/v10"
 
 	"GoMembership/pkg/errors"
 	"GoMembership/pkg/logger"
@@ -25,7 +28,7 @@ type UserController struct {
 	ConsentService     services.ConsentServiceInterface
 	BankAccountService services.BankAccountServiceInterface
 	MembershipService  services.MembershipServiceInterface
-	LicenceService     services.LicenceInterface
+	LicenceService     services.LicenceServiceInterface
 }
 
 type RegistrationData struct {
@@ -33,7 +36,7 @@ type RegistrationData struct {
 }
 
 func (uc *UserController) CurrentUserHandler(c *gin.Context) {
-	requestUser, err := uc.ExtractUserFromContext(c)
+	requestUser, err := uc.Service.FromContext(c)
 	if err != nil {
 		utils.RespondWithError(c, err, "Error extracting user from context in CurrentUserHandler", http.StatusBadRequest, errors.Responses.Fields.User, errors.Responses.Keys.NoAuthToken)
 		return
@@ -46,19 +49,20 @@ func (uc *UserController) CurrentUserHandler(c *gin.Context) {
 
 func (uc *UserController) GetAllUsers(c *gin.Context) {
 
-	requestUser, err := uc.ExtractUserFromContext(c)
+	requestUser, err := uc.Service.FromContext(c)
 	if err != nil {
 		utils.RespondWithError(c, err, "Error extracting user from context in UpdateHandler", http.StatusBadRequest, errors.Responses.Fields.User, errors.Responses.Keys.NoAuthToken)
 		return
 	}
-	if !utils.HasPrivilige(requestUser, constants.Priviliges.View) {
+
+	if !requestUser.HasPrivilege(constants.Priviliges.View) {
 		utils.RespondWithError(c, errors.ErrNotAuthorized, fmt.Sprintf("Not allowed to handle all users. RoleID(%v)<Privilige(%v)", requestUser.RoleID, constants.Priviliges.View), http.StatusForbidden, errors.Responses.Fields.User, errors.Responses.Keys.Unauthorized)
 		return
 	}
 
 	users, err := uc.Service.GetUsers(nil)
 	if err != nil {
-		utils.RespondWithError(c, err, "Error getting users in GetAllUsers", http.StatusInternalServerError, errors.Responses.Fields.User, errors.Responses.Keys.InternalServerError)
+		utils.RespondWithError(c, err, "Error getting all users", http.StatusInternalServerError, errors.Responses.Fields.User, errors.Responses.Keys.InternalServerError)
 		return
 	}
 
@@ -69,6 +73,7 @@ func (uc *UserController) GetAllUsers(c *gin.Context) {
 	for i, user := range *users {
 		safeUsers[i] = user.Safe()
 	}
+
 	c.JSON(http.StatusOK, gin.H{
 		"users": users,
 	})
@@ -76,7 +81,7 @@ func (uc *UserController) GetAllUsers(c *gin.Context) {
 
 func (uc *UserController) UpdateHandler(c *gin.Context) {
 	// 1. Extract and validate the user ID from the route
-	requestUser, err := uc.ExtractUserFromContext(c)
+	requestUser, err := uc.Service.FromContext(c)
 	if err != nil {
 		utils.RespondWithError(c, err, "Error extracting user from context in UpdateHandler", http.StatusBadRequest, errors.Responses.Fields.User, errors.Responses.Keys.NoAuthToken)
 		return
@@ -89,28 +94,20 @@ func (uc *UserController) UpdateHandler(c *gin.Context) {
 	}
 	user := updateData.User
 
-	if !utils.HasPrivilige(requestUser, constants.Priviliges.Update) && user.ID != requestUser.ID {
+	if !requestUser.HasPrivilege(constants.Priviliges.Update) && user.ID != requestUser.ID {
 		utils.RespondWithError(c, errors.ErrNotAuthorized, "Not allowed to update user", http.StatusForbidden, errors.Responses.Fields.User, errors.Responses.Keys.Unauthorized)
 		return
 	}
-	existingUser, err := uc.Service.GetUserByID(user.ID)
-	if err != nil {
-		utils.RespondWithError(c, err, "Error finding an existing user", http.StatusNotFound, errors.Responses.Fields.User, errors.Responses.Keys.NotFound)
-		return
-	}
-	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
 
-	if requestUser.RoleID <= constants.Priviliges.View {
+	if requestUser.IsMember() {
+		existingUser, err := uc.Service.FromID(&user.ID)
+		if err != nil {
+			utils.RespondWithError(c, err, "Error finding an existing user", http.StatusNotFound, errors.Responses.Fields.User, errors.Responses.Keys.NotFound)
+			return
+		}
 		// deleting existing Users Password to prevent it from being recognized as changed in any case. (Incoming Password is empty if not changed)
 		existingUser.Password = ""
-		if err := utils.FilterAllowedStructFields(&user, existingUser, constants.MemberUpdateFields, ""); err != nil {
+		if err := validation.FilterAllowedStructFields(&user, existingUser, constants.MemberUpdateFields, ""); err != nil {
 			if err.Error() == "Not authorized" {
 				utils.RespondWithError(c, errors.ErrNotAuthorized, "Trying to update unauthorized fields", http.StatusUnauthorized, errors.Responses.Fields.User, errors.Responses.Keys.Unauthorized)
 			} else {
@@ -120,20 +117,20 @@ func (uc *UserController) UpdateHandler(c *gin.Context) {
 		}
 	}
 
-	updatedUser, err := uc.Service.UpdateUser(&user)
+	updatedUser, err := uc.Service.Update(&user)
 	if err != nil {
 		utils.HandleUserUpdateError(c, err)
 		return
 	}
 
-	logger.Info.Printf("User %d updated successfully by user %d", updatedUser.ID, requestUser.ID)
+	logger.Info.Printf("User %v updated successfully by user %v", updatedUser.Email, requestUser.Email)
 
 	c.JSON(http.StatusAccepted, gin.H{"message": "User updated successfully", "user": updatedUser.Safe()})
 }
 
 func (uc *UserController) DeleteUser(c *gin.Context) {
 
-	requestUser, err := uc.ExtractUserFromContext(c)
+	requestUser, err := uc.Service.FromContext(c)
 	if err != nil {
 		utils.RespondWithError(c, err, "Error extracting user from context in DeleteUser", http.StatusBadRequest, errors.Responses.Fields.User, errors.Responses.Keys.NoAuthToken)
 		return
@@ -152,13 +149,13 @@ func (uc *UserController) DeleteUser(c *gin.Context) {
 		return
 	}
 
-	if !utils.HasPrivilige(requestUser, constants.Priviliges.Delete) && data.User.ID != requestUser.ID {
+	if !requestUser.HasPrivilege(constants.Priviliges.Delete) && data.User.ID != requestUser.ID {
 		utils.RespondWithError(c, errors.ErrNotAuthorized, "Not allowed to delete user", http.StatusForbidden, errors.Responses.Fields.User, errors.Responses.Keys.Unauthorized)
 		return
 	}
 
 	logger.Error.Printf("Deleting user: %v", data.User)
-	if err := uc.Service.DeleteUser(data.User.LastName, data.User.ID); err != nil {
+	if err := uc.Service.Delete(&data.User.ID); err != nil {
 		utils.HandleDeleteUserError(c, err)
 		return
 	}
@@ -166,24 +163,6 @@ func (uc *UserController) DeleteUser(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{"message": "User deleted successfully"})
 }
 
-func (uc *UserController) ExtractUserFromContext(c *gin.Context) (*models.User, error) {
-
-	tokenString, err := c.Cookie("jwt")
-	if err != nil {
-		return nil, err
-	}
-	_, claims, err := middlewares.ExtractContentFrom(tokenString)
-	if err != nil {
-		return nil, err
-	}
-	jwtUserID := uint((*claims)["user_id"].(float64))
-	user, err := uc.Service.GetUserByID(jwtUserID)
-	if err != nil {
-		return nil, err
-	}
-	return user, nil
-}
-
 func (uc *UserController) LogoutHandler(c *gin.Context) {
 	tokenString, err := c.Cookie("jwt")
 	if err != nil {
@@ -207,7 +186,7 @@ func (uc *UserController) LoginHandler(c *gin.Context) {
 		return
 	}
 
-	user, err := uc.Service.GetUserByEmail(input.Email)
+	user, err := uc.Service.FromEmail(&input.Email)
 	if err != nil {
 		utils.RespondWithError(c, err, "Login Error; user not found", http.StatusNotFound,
 			errors.Responses.Fields.Login,
@@ -215,9 +194,9 @@ func (uc *UserController) LoginHandler(c *gin.Context) {
 		return
 	}
 
-	if user.Status <= constants.DisabledStatus {
-		utils.RespondWithError(c, fmt.Errorf("User banned from login %v %v", user.FirstName, user.LastName),
-			"Login Error; user is disabled",
+	if !user.IsVerified() {
+		utils.RespondWithError(c, fmt.Errorf("User banned from login or not verified %v %v", user.FirstName, user.LastName),
+			"Login Error; user is disabled or not verified",
 			http.StatusNotAcceptable,
 			errors.Responses.Fields.Login,
 			errors.Responses.Keys.UserDisabled)
@@ -238,8 +217,10 @@ func (uc *UserController) LoginHandler(c *gin.Context) {
 		return
 	}
 
-	logger.Error.Printf("jwtsecret: %v", config.Auth.JWTSecret)
-	token, err := middlewares.GenerateToken(config.Auth.JWTSecret, user, "")
+	// "user_id":    user.ID,
+	//	"role_id":    user.RoleID,
+	claims := map[string]interface{}{"user_id": user.ID, "role_id": user.RoleID}
+	token, err := middlewares.GenerateToken(&config.Auth.JWTSecret, claims, "")
 	if err != nil {
 		utils.RespondWithError(c, err, "Error generating token in LoginHandler", http.StatusInternalServerError, errors.Responses.Fields.Login, errors.Responses.Keys.JwtGenerationFailed)
 		return
@@ -256,7 +237,6 @@ func (uc *UserController) LoginHandler(c *gin.Context) {
 func (uc *UserController) RegisterUser(c *gin.Context) {
 
 	var regData RegistrationData
-	logger.Error.Printf("registering user...")
 	if err := c.ShouldBindJSON(&regData); err != nil {
 		utils.HandleValidationError(c, err)
 		return
@@ -269,11 +249,13 @@ func (uc *UserController) RegisterUser(c *gin.Context) {
 		return
 	}
 	regData.User.Membership.SubscriptionModel = *selectedModel
-	if selectedModel.RequiredMembershipField != "" {
-		if err := validation.CheckParentMembershipID(regData.User.Membership); err != nil {
-			utils.RespondWithError(c, err, "Error in RegisterUser, couldn't check parent membership id", http.StatusBadRequest, errors.Responses.Fields.ParentMemberShipID, errors.Responses.Keys.NotFound)
-			return
-		}
+	// Get Gin's binding validator engine with all registered validators
+	validate := binding.Validator.Engine().(*validator.Validate)
+
+	// Validate the populated user struct
+	if err := validate.Struct(regData.User); err != nil {
+		utils.HandleValidationError(c, err)
+		return
 	}
 	if regData.User.Membership.SubscriptionModel.Name == constants.SupporterSubscriptionModelName {
 		regData.User.RoleID = constants.Roles.Supporter
@@ -282,9 +264,9 @@ func (uc *UserController) RegisterUser(c *gin.Context) {
 	}
 
 	// Register User
-	id, token, err := uc.Service.RegisterUser(&regData.User)
+	id, token, err := uc.Service.Register(&regData.User)
 	if err != nil {
-		if strings.Contains(err.Error(), "UNIQUE constraint failed: users.email") {
+		if strings.Contains(err.Error(), "UNIQUE constraint failed:") {
 			utils.RespondWithError(c, err, "Error in RegisterUser, couldn't register user", http.StatusConflict, errors.Responses.Fields.Email, errors.Responses.Keys.Duplicate)
 		} else {
 			utils.RespondWithError(c, err, "Error in RegisterUser, couldn't register user", http.StatusConflict, errors.Responses.Fields.General, errors.Responses.Keys.InternalServerError)
@@ -294,7 +276,7 @@ func (uc *UserController) RegisterUser(c *gin.Context) {
 	regData.User.ID = id
 
 	// if this is a supporter don't send mails and he never did give any consent. So stop here
-	if regData.User.RoleID == constants.Roles.Supporter {
+	if regData.User.IsSupporter() {
 
 		c.JSON(http.StatusCreated, gin.H{
 			"message": "Supporter Registration successuful",
@@ -318,6 +300,7 @@ func (uc *UserController) RegisterUser(c *gin.Context) {
 			ConsentType: "Privacy",
 		},
 	}
+
 	for _, consent := range consents {
 		_, err = uc.ConsentService.RegisterConsent(&consent)
 		if err != nil {
@@ -326,6 +309,7 @@ func (uc *UserController) RegisterUser(c *gin.Context) {
 		}
 	}
 
+	logger.Error.Printf("Sending Verification mail to user with id: %#v", id)
 	// Send notifications
 	if err := uc.EmailService.SendVerificationEmail(&regData.User, &token); err != nil {
 		utils.RespondWithError(c, err, "Error in RegisterUser, couldn't send verification email", http.StatusInternalServerError, errors.Responses.Fields.Email, errors.Responses.Keys.UndeliveredVerificationMail)
@@ -351,26 +335,35 @@ func (uc *UserController) VerifyMailHandler(c *gin.Context) {
 		c.HTML(http.StatusBadRequest, "verification_error.html", gin.H{"ErrorMessage": "Missing token"})
 		return
 	}
-
-	verification, err := uc.Service.VerifyUser(&token, &constants.VerificationTypes.Email)
+	userIDint, err := strconv.Atoi(c.Param("id"))
 	if err != nil {
-		c.HTML(http.StatusBadRequest, "verification_error.html", gin.H{"ErrorMessage": "Couldn't verify user"})
+		logger.Error.Println("Missing user ID to verify mail")
+		c.HTML(http.StatusBadRequest, "verification_error.html", gin.H{"ErrorMessage": "Missing user"})
 		return
 	}
-
-	user, err := uc.Service.GetUserByID(verification.UserID)
+	userID := uint(userIDint)
+	user, err := uc.Service.FromID(&userID)
 	if err != nil {
-		c.HTML(http.StatusBadRequest, "verification_error.html", gin.H{"ErrorMessage": "Internal server error, couldn't verify user"})
+		logger.Error.Printf("Couldn't find user in verifyMailHandler: %#v", err)
+		c.HTML(http.StatusBadRequest, "verification_error.html", gin.H{"ErrorMessage": "Couldn't find user"})
+		return
+	}
+	if !user.Verify(token, constants.VerificationTypes.Email) {
+		logger.Error.Printf("Couldn't find user verification in verifyMailHandler: %v", err)
+		c.HTML(http.StatusBadRequest, "verification_error.html", gin.H{"ErrorMessage": "Couldn't find user verification request"})
 		return
 	}
 
 	user.Status = constants.VerifiedStatus
-	user.Verification = *verification
-	user.ID = verification.UserID
 	user.Password = ""
 
-	uc.Service.UpdateUser(user)
-	logger.Info.Printf("Verified User: %#v", user.Email)
+	updatedUser, err := uc.Service.Update(user)
+	if err != nil {
+		logger.Error.Printf("Failed to update user(%v) after verification: %v", user.Email, err)
+		c.HTML(http.StatusInternalServerError, "verification_error.html", gin.H{"ErrorMessage": "Internal server error, couldn't verify user"})
+		return
+	}
+	logger.Info.Printf("Verified User: %#v", updatedUser.Email)
 
 	uc.EmailService.SendWelcomeEmail(user)
 	c.HTML(http.StatusOK, "verification_success.html", gin.H{"FirstName": user.FirstName})