Tests: Membership controller

frontend/src/lib/utils/processing.js

@@ -3,10 +3,10 @@ import { toRFC3339 } from './helpers';
 /**
  * Converts FormData to a nested object structure
  * @param {FormData} formData - The FormData object to convert
- * @returns {{ user: Partial<App.Locals['user']>,password2: string }} Nested object representation of the form data
+ * @returns {{ object: Partial<App.Locals['user']> | Partial<App.Types['subscription']>, password2: string }} Nested object representation of the form data
  */
 export function formDataToObject(formData) {
-	/** @type { Partial<App.Locals['user']> } */
+	/** @type { Partial<App.Locals['user']> | Partial<App.Types['subscription']> } */
 	const object = {};
 	let password2 = '';
 
@@ -56,89 +56,113 @@ export function formDataToObject(formData) {
 		}
 	}
 
-	return { user: object, password2: password2 };
+	return { object: object, password2: password2 };
 }
 
 /**
  * Processes the raw form data into the expected user data structure
- * @param {{  user: Partial<App.Locals['user']>, password2: string} } rawData - The raw form data object
+ * @param {{  object: Partial<App.Locals['user']>, password2: string} } rawData - The raw form data object
  * @returns {{ user: Partial<App.Locals['user']> }} Processed user data
  */
-export function processFormData(rawData) {
+export function processUserFormData(rawData) {
 	/** @type {{ user: Partial<App.Locals['user']> }} */
 	let processedData = {
 		user: {
-			id: Number(rawData.user.id) || 0,
+			id: Number(rawData.object.id) || 0,
-			status: Number(rawData.user.status),
+			status: Number(rawData.object.status),
-			role_id: Number(rawData.user.role_id),
+			role_id: Number(rawData.object.role_id),
-			first_name: String(rawData.user.first_name),
+			first_name: String(rawData.object.first_name),
-			last_name: String(rawData.user.last_name),
+			last_name: String(rawData.object.last_name),
-			email: String(rawData.user.email),
+			email: String(rawData.object.email),
-			phone: String(rawData.user.phone || ''),
+			phone: String(rawData.object.phone || ''),
-			company: String(rawData.user.company || ''),
+			company: String(rawData.object.company || ''),
-			dateofbirth: toRFC3339(rawData.user.dateofbirth),
+			dateofbirth: toRFC3339(rawData.object.dateofbirth),
-			address: String(rawData.user.address || ''),
+			address: String(rawData.object.address || ''),
-			zip_code: String(rawData.user.zip_code || ''),
+			zip_code: String(rawData.object.zip_code || ''),
-			city: String(rawData.user.city || ''),
+			city: String(rawData.object.city || ''),
-			notes: String(rawData.user.notes || ''),
+			notes: String(rawData.object.notes || ''),
-			profile_picture: String(rawData.user.profile_picture || ''),
+			profile_picture: String(rawData.object.profile_picture || ''),
 
 			membership: {
-				id: Number(rawData.user.membership?.id) || 0,
+				id: Number(rawData.object.membership?.id) || 0,
-				status: Number(rawData.user.membership?.status),
+				status: Number(rawData.object.membership?.status),
-				start_date: toRFC3339(rawData.user.membership?.start_date),
+				start_date: toRFC3339(rawData.object.membership?.start_date),
-				end_date: toRFC3339(rawData.user.membership?.end_date),
+				end_date: toRFC3339(rawData.object.membership?.end_date),
-				parent_member_id: Number(rawData.user.membership?.parent_member_id) || 0,
+				parent_member_id: Number(rawData.object.membership?.parent_member_id) || 0,
 				subscription_model: {
-					id: Number(rawData.user.membership?.subscription_model?.id) || 0,
+					id: Number(rawData.object.membership?.subscription_model?.id) || 0,
-					name: String(rawData.user.membership?.subscription_model?.name) || '',
+					name: String(rawData.object.membership?.subscription_model?.name) || '',
-					details: String(rawData.user.membership?.subscription_model?.details) || '',
+					details: String(rawData.object.membership?.subscription_model?.details) || '',
-					conditions: String(rawData.user.membership?.subscription_model?.conditions) || '',
+					conditions: String(rawData.object.membership?.subscription_model?.conditions) || '',
-					hourly_rate: Number(rawData.user.membership?.subscription_model?.hourly_rate) || 0,
+					hourly_rate: Number(rawData.object.membership?.subscription_model?.hourly_rate) || 0,
-					monthly_fee: Number(rawData.user.membership?.subscription_model?.monthly_fee) || 0,
+					monthly_fee: Number(rawData.object.membership?.subscription_model?.monthly_fee) || 0,
 					included_hours_per_month:
-						Number(rawData.user.membership?.subscription_model?.included_hours_per_month) || 0,
+						Number(rawData.object.membership?.subscription_model?.included_hours_per_month) || 0,
 					included_hours_per_year:
-						Number(rawData.user.membership?.subscription_model?.included_hours_per_year) || 0
+						Number(rawData.object.membership?.subscription_model?.included_hours_per_year) || 0
 				}
 			},
 
 			licence: {
-				id: Number(rawData.user.licence?.id) || 0,
+				id: Number(rawData.object.licence?.id) || 0,
-				status: Number(rawData.user.licence?.status),
+				status: Number(rawData.object.licence?.status),
-				number: String(rawData.user.licence?.number || ''),
+				number: String(rawData.object.licence?.number || ''),
-				issued_date: toRFC3339(rawData.user.licence?.issued_date),
+				issued_date: toRFC3339(rawData.object.licence?.issued_date),
-				expiration_date: toRFC3339(rawData.user.licence?.expiration_date),
+				expiration_date: toRFC3339(rawData.object.licence?.expiration_date),
-				country: String(rawData.user.licence?.country || ''),
+				country: String(rawData.object.licence?.country || ''),
-				categories: rawData.user.licence?.categories || []
+				categories: rawData.object.licence?.categories || []
 			},
 
 			bank_account: {
-				id: Number(rawData.user.bank_account?.id) || 0,
+				id: Number(rawData.object.bank_account?.id) || 0,
-				account_holder_name: String(rawData.user.bank_account?.account_holder_name || ''),
+				account_holder_name: String(rawData.object.bank_account?.account_holder_name || ''),
-				bank: String(rawData.user.bank_account?.bank || ''),
+				bank: String(rawData.object.bank_account?.bank || ''),
-				iban: String(rawData.user.bank_account?.iban || ''),
+				iban: String(rawData.object.bank_account?.iban || ''),
-				bic: String(rawData.user.bank_account?.bic || ''),
+				bic: String(rawData.object.bank_account?.bic || ''),
-				mandate_reference: String(rawData.user.bank_account?.mandate_reference || ''),
+				mandate_reference: String(rawData.object.bank_account?.mandate_reference || ''),
-				mandate_date_signed: toRFC3339(rawData.user.bank_account?.mandate_date_signed)
+				mandate_date_signed: toRFC3339(rawData.object.bank_account?.mandate_date_signed)
 			}
 		}
 	};
 	console.log('Categories: --------');
-	console.dir(rawData.user.licence);
+	console.dir(rawData.object.licence);
 	if (
-		rawData.user.password &&
+		rawData.object.password &&
 		rawData.password2 &&
-		rawData.user.password === rawData.password2 &&
+		rawData.object.password === rawData.password2 &&
-		rawData.user.password.trim() !== ''
+		rawData.object.password.trim() !== ''
 	) {
-		processedData.user.password = rawData.user.password;
+		processedData.user.password = rawData.object.password;
 	}
-
+	const clean = JSON.parse(JSON.stringify(processedData), (key, value) =>
-	// Remove undefined or null properties
-	const cleanUpdateData = JSON.parse(JSON.stringify(processedData), (key, value) =>
 		value !== null && value !== '' ? value : undefined
 	);
-	console.dir(cleanUpdateData);
+	console.dir(clean);
-	return cleanUpdateData;
+	return clean;
+}
+
+/**
+ * Processes the raw form data into the expected user data structure
+ * @param {{  object: Partial<App.Types['subscription']>} } rawData - The raw form data object
+ * @returns {{ subscription: Partial<App.Types['subscription']> }} Processed user data
+ */
+export function processSubscriptionFormData(rawData) {
+	/** @type {{ subscription: Partial<App.Types['subscription']> }} */
+	let processedData = {
+		subscription: {
+			id: Number(rawData.object.id) || 0,
+			name: String(rawData.object.name) || '',
+			details: String(rawData.object.details) || '',
+			conditions: String(rawData.object.conditions) || '',
+			hourly_rate: Number(rawData.object.hourly_rate) || 0,
+			monthly_fee: Number(rawData.object.monthly_fee) || 0,
+			included_hours_per_month: Number(rawData.object.included_hours_per_month) || 0,
+			included_hours_per_year: Number(rawData.object.included_hours_per_year) || 0
+		}
+	};
+	const clean = JSON.parse(JSON.stringify(processedData), (key, value) =>
+		value !== null && value !== '' ? value : undefined
+	);
+	console.dir(clean);
+	return clean;
 }

frontend/src/routes/auth/about/[id]/+page.server.js

@@ -1,7 +1,7 @@
 import { BASE_API_URI } from '$lib/utils/constants';
 import { formatError, userDatesFromRFC3339 } from '$lib/utils/helpers';
 import { fail, redirect } from '@sveltejs/kit';
-import { formDataToObject, processFormData } from '$lib/utils/processing';
+import { formDataToObject, processUserFormData } from '$lib/utils/processing';
 
 /**
  * @typedef {Object} UpdateData
@@ -30,7 +30,7 @@ export const actions = {
 		let formData = await request.formData();
 
 		const rawData = formDataToObject(formData);
-		const processedData = processFormData(rawData);
+		const processedData = processUserFormData(rawData);
 
 		const isCreating = !processedData.user.id || processedData.user.id === 0;
 		console.log('Is creating: ', isCreating);

frontend/src/routes/auth/admin/users/+page.server.js

@@ -5,7 +5,11 @@
 import { BASE_API_URI } from '$lib/utils/constants';
 import { formatError, userDatesFromRFC3339 } from '$lib/utils/helpers';
 import { fail, redirect } from '@sveltejs/kit';
-import { formDataToObject, processFormData } from '$lib/utils/processing';
+import {
+	formDataToObject,
+	processSubscriptionFormData,
+	processUserFormData
+} from '$lib/utils/processing';
 
 /** @type {import('./$types').PageServerLoad} */
 export async function load({ locals }) {
@@ -29,7 +33,7 @@ export const actions = {
 		let formData = await request.formData();
 
 		const rawData = formDataToObject(formData);
-		const processedData = processFormData(rawData);
+		const processedData = processUserFormData(rawData);
 
 		console.dir(processedData.user.membership);
 		const isCreating = !processedData.user.id || processedData.user.id === 0;
@@ -55,6 +59,49 @@ export const actions = {
 			return fail(400, { errors: errors });
 		}
 
+		const response = await res.json();
+		console.log('Server success response:', response);
+		locals.user = response;
+		userDatesFromRFC3339(locals.user);
+		throw redirect(303, `/auth/admin/users`);
+	},
+	/**
+	 *
+	 * @param request - The request object
+	 * @param fetch - Fetch object from sveltekit
+	 * @param cookies - SvelteKit's cookie object
+	 * @param locals - The local object, housing current user
+	 * @returns Error data or redirects user to the home page or the previous page
+	 */
+	updateSubscription: async ({ request, fetch, cookies, locals }) => {
+		let formData = await request.formData();
+
+		const rawData = formDataToObject(formData);
+		const processedData = processSubscriptionFormData(rawData);
+
+		const isCreating = !processedData.subscription.id || processedData.subscription.id === 0;
+		console.log('Is creating: ', isCreating);
+		const apiURL = `${BASE_API_URI}/backend/subscriptions/upsert`;
+
+		/** @type {RequestInit} */
+		const requestOptions = {
+			method: isCreating ? 'POST' : 'PATCH',
+			credentials: 'include',
+			headers: {
+				'Content-Type': 'application/json',
+				Cookie: `jwt=${cookies.get('jwt')}`
+			},
+			body: JSON.stringify(processedData)
+		};
+
+		const res = await fetch(apiURL, requestOptions);
+
+		if (!res.ok) {
+			const response = await res.json();
+			const errors = formatError(response.errors);
+			return fail(400, { errors: errors });
+		}
+
 		const response = await res.json();
 		console.log('Server success response:', response);
 		locals.user = response;

internal/controllers/controllers_test.go

@@ -106,7 +106,7 @@ func TestSuite(t *testing.T) {
 	licenceService := &services.LicenceService{Repo: licenceRepo}
 
 	Uc = &UserController{Service: userService, LicenceService: licenceService, EmailService: emailService, ConsentService: consentService, BankAccountService: bankAccountService, MembershipService: membershipService}
-	Mc = &MembershipController{Service: *membershipService}
+	Mc = &MembershipController{UserController: &MockUserController{}, Service: *membershipService}
 	Cc = &ContactController{EmailService: emailService}
 
 	if err := initSubscriptionPlans(); err != nil {

internal/controllers/membershipController.go

@@ -1,36 +1,54 @@
 package controllers
 
 import (
+	"GoMembership/internal/constants"
 	"GoMembership/internal/models"
 	"GoMembership/internal/services"
+	"GoMembership/internal/utils"
 	"strings"
 
 	"net/http"
-	// "strconv"
+
 	"github.com/gin-gonic/gin"
 
+	"GoMembership/pkg/errors"
 	"GoMembership/pkg/logger"
 )
 
 type MembershipController struct {
 	Service        services.MembershipService
+	UserController interface {
+		ExtractUserFromContext(*gin.Context) (*models.User, error)
+	}
 }
 
 type MembershipData struct {
-	APIKey string                   `json:"api_key"`
+	// APIKey string                   `json:"api_key"`
-	Model  models.SubscriptionModel `json:"model"`
+	Subscription models.SubscriptionModel `json:"subscription"`
 }
 
 func (mc *MembershipController) RegisterSubscription(c *gin.Context) {
 	var regData MembershipData
+
+	requestUser, err := mc.UserController.ExtractUserFromContext(c)
+	if err != nil {
+		utils.RespondWithError(c, err, "Error extracting user from context in subscription registrationHandler", http.StatusBadRequest, "general", "server.validation.invalid_user_data")
+		return
+	}
+
+	if !utils.HasPrivilige(requestUser, constants.Priviliges.Update) {
+		utils.RespondWithError(c, errors.ErrNotAuthorized, "Not allowed to register subscription", http.StatusForbidden, "user", "server.error.unauthorized")
+		return
+	}
+
 	if err := c.ShouldBindJSON(&regData); err != nil {
-		logger.Error.Printf("Couln't decode subscription data: %v", err)
+		utils.HandleValidationError(c, err)
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Couldn't decode subscription data"})
 		return
 	}
 
 	// Register Subscription
-	id, err := mc.Service.RegisterSubscription(&regData.Model)
+	logger.Info.Printf("Registering subscription %v", regData.Subscription.Name)
+	id, err := mc.Service.RegisterSubscription(&regData.Subscription)
 	if err != nil {
 		logger.Error.Printf("Couldn't register Membershipmodel: %v", err)
 		if strings.Contains(err.Error(), "UNIQUE constraint failed") {
@@ -47,6 +65,44 @@ func (mc *MembershipController) RegisterSubscription(c *gin.Context) {
 	})
 }
 
+func (mc *MembershipController) UpdateHandler(c *gin.Context) {
+	var regData MembershipData
+
+	requestUser, err := mc.UserController.ExtractUserFromContext(c)
+	if err != nil {
+		utils.RespondWithError(c, err, "Error extracting user from context in subscription UpdateHandler", http.StatusBadRequest, "general", "server.validation.no_auth_tokenw")
+		return
+	}
+
+	if !utils.HasPrivilige(requestUser, constants.Priviliges.Update) {
+		utils.RespondWithError(c, errors.ErrNotAuthorized, "Not allowed to update subscription", http.StatusForbidden, "user", "server.error.unauthorized")
+		return
+	}
+
+	if err := c.ShouldBindJSON(&regData); err != nil {
+		utils.HandleValidationError(c, err)
+		return
+	}
+
+	// Register Subscription
+	logger.Info.Printf("Registering subscription %v", regData.Subscription.Name)
+	// id, err := mc.Service.UpdateSubscription(&regData.Subscription)
+	id := 1
+	if err != nil {
+		logger.Error.Printf("Couldn't update Membershipmodel: %v", err)
+		if strings.Contains(err.Error(), "UNIQUE constraint failed") {
+			c.JSON(http.StatusConflict, "Duplicate subscription name")
+			return
+		}
+		c.JSON(http.StatusNotAcceptable, "Couldn't update Membershipmodel")
+		return
+	}
+	logger.Info.Printf("updating subscription: %+v", regData)
+	c.JSON(http.StatusAccepted, gin.H{
+		"status": "success",
+		"id":     id,
+	})
+}
 func (mc *MembershipController) GetSubscriptions(c *gin.Context) {
 	subscriptions, err := mc.Service.GetSubscriptions(nil)
 	if err != nil {

internal/controllers/membershipController_test.go

@@ -6,7 +6,7 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"GoMembership/internal/config"
+	"GoMembership/internal/constants"
 	"GoMembership/internal/models"
 	"GoMembership/pkg/logger"
 
@@ -21,8 +21,29 @@ type RegisterSubscriptionTest struct {
 	Assert       bool
 }
 
+type MockUserController struct {
+	UserController // Embed the UserController
+}
+
+func (m *MockUserController) ExtractUserFromContext(c *gin.Context) (*models.User, error) {
+	return &models.User{
+		ID:        1,
+		FirstName: "Admin",
+		LastName:  "User",
+		Email:     "admin@test.com",
+		RoleID:    constants.Roles.Admin,
+	}, nil
+}
+
+func setupMockAuth() {
+	// Create and assign the mock controller
+	mockController := &MockUserController{}
+	Mc.UserController = mockController
+}
+
 func testMembershipController(t *testing.T) {
 
+	setupMockAuth()
 	tests := getSubscriptionData()
 	for _, tt := range tests {
 		logger.Error.Print("==============================================================")
@@ -68,8 +89,8 @@ func validateSubscription(assert bool, wantDBData map[string]interface{}) error
 
 func getBaseSubscription() MembershipData {
 	return MembershipData{
-		APIKey: config.Auth.APIKEY,
+		// APIKey: config.Auth.APIKEY,
-		Model: models.SubscriptionModel{
+		Subscription: models.SubscriptionModel{
 			Name:       "Premium",
 			Details:    "A subscription detail",
 			MonthlyFee: 12.0,
@@ -91,7 +112,7 @@ func getSubscriptionData() []RegisterSubscriptionTest {
 			Assert:       false,
 			Input: GenerateInputJSON(
 				customizeSubscription(func(subscription MembershipData) MembershipData {
-					subscription.Model.Details = ""
+					subscription.Subscription.Details = ""
 					return subscription
 				})),
 		},
@@ -102,7 +123,7 @@ func getSubscriptionData() []RegisterSubscriptionTest {
 			Assert:       false,
 			Input: GenerateInputJSON(
 				customizeSubscription(func(subscription MembershipData) MembershipData {
-					subscription.Model.Name = ""
+					subscription.Subscription.Name = ""
 					return subscription
 				})),
 		},
@@ -112,7 +133,7 @@ func getSubscriptionData() []RegisterSubscriptionTest {
 			WantDBData:   map[string]interface{}{"name": "Premium"},
 			Assert:       false,
 			Input: GenerateInputJSON(customizeSubscription(func(sub MembershipData) MembershipData {
-				sub.Model.MonthlyFee = -10.0
+				sub.Subscription.MonthlyFee = -10.0
 				return sub
 			})),
 		},
@@ -122,7 +143,7 @@ func getSubscriptionData() []RegisterSubscriptionTest {
 			WantDBData:   map[string]interface{}{"name": "Premium"},
 			Assert:       false,
 			Input: GenerateInputJSON(customizeSubscription(func(sub MembershipData) MembershipData {
-				sub.Model.HourlyRate = -1.0
+				sub.Subscription.HourlyRate = -1.0
 				return sub
 			})),
 		},
@@ -133,9 +154,9 @@ func getSubscriptionData() []RegisterSubscriptionTest {
 			Assert:       true,
 			Input: GenerateInputJSON(
 				customizeSubscription(func(subscription MembershipData) MembershipData {
-					subscription.Model.Conditions = "Some Condition"
+					subscription.Subscription.Conditions = "Some Condition"
-					subscription.Model.IncludedPerYear = 0
+					subscription.Subscription.IncludedPerYear = 0
-					subscription.Model.IncludedPerMonth = 1
+					subscription.Subscription.IncludedPerMonth = 1
 					return subscription
 				})),
 		},

internal/controllers/user_controller.go

@@ -33,7 +33,7 @@ type RegistrationData struct {
 }
 
 func (uc *UserController) CurrentUserHandler(c *gin.Context) {
-	requestUser, err := uc.extractUserFromContext(c)
+	requestUser, err := uc.ExtractUserFromContext(c)
 	if err != nil {
 		utils.RespondWithError(c, err, "Error extracting user from context in CurrentUserHandler", http.StatusBadRequest, "general", "server.error.internal_server_error")
 		return
@@ -65,7 +65,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.ExtractUserFromContext(c)
 	if err != nil {
 		utils.RespondWithError(c, err, "Error extracting user from context in UpdateHandler", http.StatusBadRequest, "general", "server.validation.no_auth_tokenw")
 		return
@@ -86,7 +86,7 @@ func (uc *UserController) UpdateHandler(c *gin.Context) {
 
 	updatedUser, err := uc.Service.UpdateUser(&user)
 	if err != nil {
-		utils.HandleUpdateError(c, err)
+		utils.HandleUserUpdateError(c, err)
 		return
 	}
 
@@ -97,7 +97,7 @@ func (uc *UserController) UpdateHandler(c *gin.Context) {
 
 func (uc *UserController) DeleteUser(c *gin.Context) {
 
-	requestUser, err := uc.extractUserFromContext(c)
+	requestUser, err := uc.ExtractUserFromContext(c)
 	if err != nil {
 		utils.RespondWithError(c, err, "Error extracting user from context in UpdateHandler", http.StatusBadRequest, "general", "server.validation.no_auth_tokenw")
 		return
@@ -125,7 +125,7 @@ func (uc *UserController) DeleteUser(c *gin.Context) {
 	}
 }
 
-func (uc *UserController) extractUserFromContext(c *gin.Context) (*models.User, error) {
+func (uc *UserController) ExtractUserFromContext(c *gin.Context) (*models.User, error) {
 
 	tokenString, err := c.Cookie("jwt")
 	if err != nil {

internal/routes/routes.go

@@ -15,11 +15,11 @@ func RegisterRoutes(router *gin.Engine, userController *controllers.UserControll
 	router.POST("/users/login", userController.LoginHandler)
 	router.POST("/csp-report", middlewares.CSPReportHandling)
 
-	apiRouter := router.Group("/api")
+	// apiRouter := router.Group("/api")
-	apiRouter.Use(middlewares.APIKeyMiddleware())
+	// apiRouter.Use(middlewares.APIKeyMiddleware())
-	{
+	// {
-		apiRouter.POST("/v1/subscription", membershipcontroller.RegisterSubscription)
+	// 	apiRouter.POST("/v1/subscription", membershipcontroller.RegisterSubscription)
-	}
+	// }
 
 	userRouter := router.Group("/backend/users")
 	userRouter.Use(middlewares.AuthMiddleware())
@@ -36,6 +36,9 @@ func RegisterRoutes(router *gin.Engine, userController *controllers.UserControll
 	membershipRouter.Use(middlewares.AuthMiddleware())
 	{
 		membershipRouter.GET("/subscriptions", membershipcontroller.GetSubscriptions)
+		membershipRouter.PATCH("/subscriptions", membershipcontroller.UpdateHandler)
+		membershipRouter.POST("/subscriptions", membershipcontroller.RegisterSubscription)
+
 	}
 
 	licenceRouter := router.Group("/backend/licence")

internal/server/server.go

@@ -46,7 +46,7 @@ func Run() {
 	userService := &services.UserService{Repo: userRepo, Licences: licenceRepo}
 
 	userController := &controllers.UserController{Service: userService, EmailService: emailService, ConsentService: consentService, LicenceService: licenceService, BankAccountService: bankAccountService, MembershipService: membershipService}
-	membershipController := &controllers.MembershipController{Service: *membershipService}
+	membershipController := &controllers.MembershipController{Service: *membershipService, UserController: userController}
 	licenceController := &controllers.LicenceController{Service: *licenceService}
 	contactController := &controllers.ContactController{EmailService: emailService}
 

internal/utils/response_handler.go

@@ -36,7 +36,7 @@ func HandleValidationError(c *gin.Context, err error) {
 	c.JSON(http.StatusBadRequest, gin.H{"errors": validationErrors})
 }
 
-func HandleUpdateError(c *gin.Context, err error) {
+func HandleUserUpdateError(c *gin.Context, err error) {
 	switch err {
 	case errors.ErrUserNotFound:
 		RespondWithError(c, err, "Error while updating user", http.StatusNotFound, "user", "server.validation.user_not_found")