Training-VehicleService-May26/Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/UserManagementService.cpp

/*
File: UserManagementService.cpp
Description: Implementation file containing the method definitions of the
			 UserManagementService class, including user creation, updates,
			 and ensuring an admin account exists.
Author: Trenser
Date:19-May-2026
*/
#include <stdexcept>
#include "Config.h"
#include "Enums.h"
#include "Factory.h"
#include "InventoryManagementService.h"
#include "PaymentManagementService.h"
#include "ServiceManagementService.h"
#include "User.h"
#include "UserManagementService.h"
#include "Vector.h"


/*
Function: ensureAdminExists
Description: Ensures that at least one admin user exists in the system.
			 If no admin is found, creates a default admin user using
			 configuration constants.
Parameter: None
Return type: void
*/
void UserManagementService::ensureAdminExists()
{
	auto& usersMap = m_dataStore.getUsers();
	int usersMapSize = usersMap.getSize();
	bool isAdminFound = false;
	for (int index = 0; index < usersMapSize; index++)
	{
		User* user = usersMap.getValueAt(index);
		if (user && user->getUserType() == util::UserType::ADMIN)
		{
			isAdminFound = true;
			break;
		}
	}
	if (!isAdminFound)
	{
		createUser(
			config::admin::DEFAULT_ADMIN_USERNAME,
			config::admin::DEFAULT_ADMIN_NAME,
			config::admin::DEFAULT_ADMIN_PASSWORD,
			config::admin::DEFAULT_ADMIN_EMAIL,
			config::admin::DEFAULT_ADMIN_PHONE, 
			util::UserType::ADMIN);
	}
}

/*
Function: createUser
Description: Creates a new user with the provided details. Validates that
			 the username is unique, then attaches the user to relevant
			 management services (payment, service, inventory).
Parameter: const std::string& username - user’s username
		   const std::string& name - user’s name
		   const std::string& password - user’s password
		   const std::string& email - user’s email address
		   const std::string& phone - user’s phone number
		   util::UserType type - type of user (ADMIN, CUSTOMER, TECHNICIAN)
Return type: void
*/
void UserManagementService::createUser(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone, util::UserType type)
{
	InventoryManagementService inventoryManagementService;
	PaymentManagementService paymentManagementService;
	ServiceManagementService serviceManagementService;
	auto& usersMap = m_dataStore.getUsers();
	int index = usersMap.findIf(
		[&](const std::string&, User* user)
		{
			return user->getUserName() == username;
		}
	);
	if (index != -1)
	{
		throw std::runtime_error("Username already exists");
	}
	User* newUser = Factory::getObject<User>(username, password, name, phone, email, type);
	usersMap.insert(newUser->getId(), newUser);
	paymentManagementService.attach(newUser);
	serviceManagementService.attach(newUser);
	if (newUser->getUserType() == util::UserType::ADMIN)
	{
		inventoryManagementService.attach(newUser);
	}
}

/*
Function: updateUserDetails
Description: Updates the email and phone details of an existing user.
			 Throws an exception if the user does not exist.
Parameter: const std::string& userID - ID of the user to update
		   const std::string& email - new email address
		   const std::string& phone - new phone number
Return type: void
*/
void UserManagementService::updateUserDetails(const std::string& userID, const std::string& email, const std::string& phone)
{
	auto& usersMap = m_dataStore.getUsers();
	int index = usersMap.find(userID);
	if (index == -1)
	{
		throw std::runtime_error("User does not exist!");
	}
	User* user = usersMap.getValueAt(index);
	user->setEmail(email);
	user->setPhone(phone);
}

/*
Function: getUserNotifications
Description: Retrieves all notifications associated with a given user ID.
Parameters:
	- userID: The unique ID of the user whose notifications are to be retrieved.
Returns:
	- util::Vector<Notification*> containing all notifications for the user.
Throws:
	- std::runtime_error if no user is found with the given UserID or if the User object is invalid.
*/
util::Vector<Notification*> UserManagementService::getUserNotifications(const std::string& userID)
{
	auto& usersMap = m_dataStore.getUsers();
	if (usersMap.find(userID) == -1)
	{
		throw std::runtime_error("No user found with given UserID");
	}
	User* user = usersMap[userID];
	if (user)
	{
		auto& notifications = user->getNotifications();
		int numberOfNotifications = notifications.getSize();
		util::Vector<Notification*> notificationsVector;
		for (int index = 0; index < numberOfNotifications; index++)
		{
		    notificationsVector.push_back(notifications.getValueAt(index));
		}
		return notificationsVector;
	}
	else
	{
		throw std::runtime_error("Invalid User object");
	}
}

/*
Function: deleteNotification
Description: Deletes a specific notification associated with a given user ID.
Parameters:
	- notificationID: The unique ID of the notification to be deleted.
	- userID: The unique ID of the user whose notification is to be deleted.
Returns:
	- void
Throws:
	- std::runtime_error if no user is found with the given UserID or if no notification is found with the given NotificationID.
*/
void UserManagementService::deleteNotification(const std::string& notificationID, const std::string& userID)
{
	auto& usersMap = m_dataStore.getUsers();
	if (usersMap.find(userID) == -1)
	{
		throw std::runtime_error("No user found with given UserID");
	}
	User* user = usersMap[userID];
	auto& notifications = user->getNotifications();
	if (notifications.find(notificationID) == -1)
	{
		throw std::runtime_error("No notification found with given NotificationID");
	}
	notifications.remove(notificationID);
}