Training-VehicleService-May26/Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/controllers/Controller.cpp

/*
File: Controller.cpp
Description: Implementation file containing the method definitions
             of the Controller class, which manages user authentication,
             inventory, services, bookings, and notifications.
Author: Trenser
Date:19-May-2026
*/
#include "Controller.h"
#include "ComboPackage.h"
#include "Enums.h"
#include "InventoryItem.h"
#include "Invoice.h"
#include "JobCard.h"
#include "Service.h"
#include "ServiceBooking.h"
#include "User.h"
#include "User.h"
#include <stdexcept>

/*
Function: login
Description: Authenticates a user based on provided credentials.
Parameter: const std::string& username - the username of the user
           const std::string& password - the password of the user
Return type: bool
*/
bool Controller::login(const std::string& username, const std::string& password)
{
    return m_authenticationManagementService.login(username, password);
}

/*
Function: logout
Description: Logs out the currently authenticated user by delegating
             to the authentication management service.
Parameter: None
Return type: void
*/
void Controller::logout()
{
    m_authenticationManagementService.logout();
}

/*
Function: changePassword
Description: Updates the password of the authenticated user by delegating
             to the authentication management service.
Parameter: const std::string& newPassword - the new password to set
Return type: void
*/
void Controller::changePassword(const std::string& newPassword)
{
    m_authenticationManagementService.changePassword(newPassword);
}

void Controller::createCustomer(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone)
{
    m_userManagementService.createUser(username, name, password, email, phone, util::UserType::CUSTOMER);
}

const User* Controller::getAuthenticatedUser()
{
    return m_authenticationManagementService.getAuthenticatedUser();
}

/*
Function: createTechnician
Description: Creates a new technician account with provided details by
             delegating to the user management service.
Parameter: const std::string& username - technician's username
           const std::string& password - technician's password
           const std::string& email - technician's email address
           const std::string& phoneNumber - technician's phone number
Return type: void
*/
void Controller::createTechnician(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phoneNumber)
{
    m_userManagementService.createUser(username, name, password, email, phoneNumber, util::UserType::TECHNICIAN);
}

void Controller::updateUserDetails(const std::string& email, const std::string& phone)
{
    User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
    if (authenticatedUser == nullptr)
    {
        throw std::runtime_error("No user currently logged in!");
    }
    m_userManagementService.updateUserDetails(authenticatedUser->getId(), email, phone);
}

util::Map<std::string, const Service*> Controller::getServices()
{
    util::Map<std::string, Service*> currentServices = m_serviceManagementService.getServices();
    util::Map<std::string, const Service*> readOnlyServices;
    for (int iterator = 0; iterator < currentServices.getSize(); iterator++)
    {
        readOnlyServices.insert(currentServices.getValueAt(iterator)->getId(), currentServices.getValueAt(iterator));
    }
    return readOnlyServices;
}

/*
Function: getComboPackages
Description: Retrieves all available combo packages from the service
             management service and constructs a read-only map.
Parameter: None
Return type: util::Map<std::string, const ComboPackage*>
*/
util::Map<std::string, const ComboPackage*> Controller::getComboPackages()
{
    util::Map<std::string, ComboPackage*> currentAvailableComboPackages = m_serviceManagementService.getComboPackages();
    util::Map<std::string, const ComboPackage*> readOnlyComboPackages;
    for (int iterator = 0; iterator < currentAvailableComboPackages.getSize(); iterator++)
    {
        ComboPackage* currentComboPackage = currentAvailableComboPackages.getValueAt(iterator);
        if (currentComboPackage)
        {
            readOnlyComboPackages.insert(currentComboPackage->getId(), currentComboPackage);
        }
    }
    return readOnlyComboPackages;
}

void Controller::purchaseService(const util::Vector<std::string>& serviceIDs, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
{
    m_serviceManagementService.purchaseService(serviceIDs, vehicleNumber, vehicleBrand, vehicleModel);
}

void Controller::purchaseComboPackage(const std::string& comboPackageID, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
{
    m_serviceManagementService.purchaseComboPackage(comboPackageID, vehicleNumber, vehicleBrand, vehicleModel);
}

/*
Function: getInventoryItems
Description: Retrieves all inventory items from the inventory management service
             and constructs a read-only map for external use.
Parameter: None
Return type: util::Map<std::string, const InventoryItem*>
*/
util::Map<std::string, const InventoryItem*> Controller::getInventoryItems()
{
    auto inventoryIems = m_inventoryManagementService.getInventoryItems();
    util::Map<std::string, const InventoryItem*> readOnlyInventoryItems;
    int inventoryItemsMapSize = inventoryIems.getSize();
    for (int index = 0; index < inventoryItemsMapSize; index++)
    {
        readOnlyInventoryItems.insert(inventoryIems.getKeyAt(index), inventoryIems.getValueAt(index));
    }
    return readOnlyInventoryItems;
}

/*
Function: getInventoryItem
Description: Retrieves a specific inventory item by its ID from the inventory management service.
Parameter: const std::string& inventoryItemID - ID of the inventory item
Return type: const InventoryItem*
*/
const InventoryItem* Controller::getInventoryItem(const std::string& inventoryItemID)
{
    return m_inventoryManagementService.getInventoryItem(inventoryItemID);
}

/*
Function: addInventoryItem
Description: Adds a new inventory item with specified details to the inventory management service.
Parameter: const std::string& partName - name of the part
           int quantity - quantity of the part
           double price - price of the part
Return type: void
*/
void Controller::addInventoryItem(const std::string& partName, int quantity, double price)
{
    m_inventoryManagementService.addInventoryItem(partName, quantity, price);
}

/*
Function: removeInventoryItem
Description: Removes an inventory item from the inventory management service by its ID.
Parameter: const std::string& inventoryItemID - ID of the inventory item
Return type: void
*/
void Controller::removeInventoryItem(const std::string& inventoryItemID)
{
    m_inventoryManagementService.removeInventoryItem(inventoryItemID);
}

/*
Function: addInventoryItemStock
Description: Adds stock to an existing inventory item in the inventory management service.
Parameter: const std::string& selectedItemId - ID of the inventory item
           int quantity - quantity to add
Return type: void
*/
void Controller::addInventoryItemStock(const std::string& selectedItemId, int quantity)
{
    m_inventoryManagementService.addInventoryItemStock(selectedItemId, quantity);
}

util::Map<std::string, const ServiceBooking*> Controller::getServiceBookings()
{
    auto serviceBookings = m_serviceManagementService.getServiceBookings();
    util::Map<std::string, const ServiceBooking*> readOnlyServiceBookings;
    for (int iterator = 0; iterator < serviceBookings.getSize(); iterator++)
    {
        readOnlyServiceBookings.insert(serviceBookings.getKeyAt(iterator), serviceBookings.getValueAt(iterator));
    }
    return readOnlyServiceBookings;
}

util::Map<std::string, const ServiceBooking*> Controller::getServiceBookingsByUser(const std::string userID)
{
    util::Map<std::string, const ServiceBooking*> readOnlyServiceBookingsByUserMap;
    util::Map<std::string, ServiceBooking*> currentServiceBookingsByUser = m_serviceManagementService.getServiceBookings(userID);
    for (int iterator = 0; iterator < currentServiceBookingsByUser.getSize(); iterator++)
    {
        readOnlyServiceBookingsByUserMap.insert(currentServiceBookingsByUser.getValueAt(iterator)->getId(), currentServiceBookingsByUser.getValueAt(iterator));
    }
    return readOnlyServiceBookingsByUserMap;
}

/*
Function: getUsers
Description: Retrieves all users from the user management service and
             constructs a read-only map.
Parameter: None
Return type: util::Map<std::string, const User*>
*/
util::Map<std::string, const User*> Controller::getUsers()
{
    auto listOfUsers = m_userManagementService.getUsers();
    util::Map<std::string, const User*> readOnlyUserList;
    for (int iterator = 0; iterator < listOfUsers.getSize(); iterator++)
    {
        readOnlyUserList.insert(listOfUsers.getKeyAt(iterator), listOfUsers.getValueAt(iterator));
    }
    return readOnlyUserList;
}

util::Map<std::string, const User*> Controller::getUsers(util::UserType userType)
{
    auto userMap = m_userManagementService.getUsers(userType);
    util::Map<std::string, const User*> readOnlyUserMap;
    for (int iterator = 0; iterator < userMap.getSize(); iterator++)
    {
        readOnlyUserMap.insert(userMap.getKeyAt(iterator), userMap.getValueAt(iterator));
    }
    return readOnlyUserMap;
}

void Controller::createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID)
{
    m_serviceManagementService.createJobCard(bookingID, technicianID, serviceID);
}

void Controller::createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost)
{
    m_serviceManagementService.createService(name, inventoryItemIDs, laborCost);
}

void Controller::removeService(const std::string& serviceID)
{
    m_serviceManagementService.removeService(serviceID);
}

util::Map<std::string, const JobCard*> Controller::getJobCardsByUser()
{
    const User* currentUser = getAuthenticatedUser();
    auto jobCardsAssignedToTechnician = m_serviceManagementService.getJobCards(currentUser->getId());
    util::Map<std::string, const JobCard*> readOnlyJobCardMap;
    for (int iterator = 0; iterator < jobCardsAssignedToTechnician.getSize(); iterator++)
    {
        JobCard* currentJobCard = jobCardsAssignedToTechnician.getValueAt(iterator);
        readOnlyJobCardMap.insert(currentJobCard->getId(), currentJobCard);
    }
    return readOnlyJobCardMap;
}

void Controller::completeJob(const std::string& jobID)
{
    m_serviceManagementService.completeJob(jobID);
}

/*
Function: removeUser
Description: Removes a user by ID. Cancels associated service bookings
             and technician jobs before removing the user from the system.
Parameter: const std::string& userID - ID of the user to remove
Return type: void
*/
void Controller::removeUser(const std::string& userID)
{
    User* user = m_userManagementService.getUser(userID);
    if (!user)
    {
        throw std::runtime_error("Error User not Found.\n");
    }
    m_serviceManagementService.cancelCustomerServiceBookings(userID);
    m_serviceManagementService.cancelTechnicianJobs(userID);
    m_userManagementService.removeUser(userID);
}

/*
Function: createComboPackage
Description: Creates a new combo package with specified services and discount
             percentage by delegating to the service management service.
Parameter: const std::string& name - name of the combo package
           const util::Vector<std::string>& serviceIDs - list of service IDs
           double discountPercentage - discount percentage for the package
Return type: void
*/
void Controller::createComboPackage(const std::string& name, const util::Vector<std::string>& serviceIDs, double discountPercentage)
{
    m_serviceManagementService.createComboPackage(name, serviceIDs, discountPercentage);
}

/*
Function: removeComboPackage
Description: Removes a combo package by ID by delegating to the service
             management service.
Parameter: const std::string& comboPackageID - ID of the combo package
Return type: void
*/
void Controller::removeComboPackage(const std::string& comboPackageID)
{
    m_serviceManagementService.removeComboPackage(comboPackageID);
}

util::Map<std::string, const Invoice*> Controller::getInvoicesByUser()
{
    User* currentUser = m_authenticationManagementService.getAuthenticatedUser();
    util::Map<std::string, Invoice*> currentUserInvoices =  m_paymentManagementService.getInvoices(currentUser->getId());
    util::Map<std::string, const Invoice*> userInvoicesReadOnly;
    for (int iterator = 0; iterator < currentUserInvoices.getSize(); iterator++)
    {
        Invoice* currentInvoice = currentUserInvoices.getValueAt(iterator);
        userInvoicesReadOnly.insert(currentInvoice->getId(), currentInvoice);
    }
    return userInvoicesReadOnly;
}

void Controller::completePayment(const std::string& invoiceID, util::PaymentMode paymentMode)
{
    m_paymentManagementService.completePayment(invoiceID, paymentMode);
}

/*
Function: getNotifications
Description: Retrieves all notifications for the currently authenticated user.
             Converts them into a read-only vector before returning.
Parameters: None
Return type: util::Vector<const Notification*>
*/
util::Vector<const Notification*> Controller::getNotifications()
{
    const User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
    if (!authenticatedUser)
    {
        throw std::runtime_error("No user is currently logged in!");
    }
    auto notifications = m_userManagementService.getUserNotifications(authenticatedUser->getId());
    int numberOfNotifications = notifications.getSize();
    util::Vector<const Notification*> readOnlyNotifications;
    for (int index = 0; index < numberOfNotifications; index++)
    {
        readOnlyNotifications.push_back(notifications[index]);
    }
    return readOnlyNotifications;
}

/*
Function: deleteNotification
Description: Deletes a specific notification for the currently authenticated user.
Parameters:
    - notificationID: std::string, the unique identifier of the notification
Return type: void
*/
void Controller::deleteNotification(const std::string& notificationID)
{
    const User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
    if (!authenticatedUser)
    {
        throw std::runtime_error("No user is currently logged in!");
    }
    m_userManagementService.deleteNotification(notificationID, authenticatedUser->getId());
}

/*
Function: configureNotifications
Description: Configures notification preferences for the authenticated user.
             Attaches or detaches the user from payment and service notifications.
Parameters:
    - paymentNotifications: bool, enable/disable payment notifications
    - serviceNotifications: bool, enable/disable service notifications
Return type: void
*/
void Controller::configureNotifications(bool paymentNotifications, bool serviceNotifications)
{
    User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
    if (authenticatedUser)
    {
        if (paymentNotifications)
        {
            m_paymentManagementService.attach(authenticatedUser);
        }
        else
        {
            m_paymentManagementService.detach(authenticatedUser);
        }
        if (serviceNotifications)
        {
            m_serviceManagementService.attach(authenticatedUser);
        }
        else
        {
            m_serviceManagementService.detach(authenticatedUser);
        }
    }
    else
    {
        throw std::runtime_error("No user is currently logged in!");
    }
}

/*
Function: runSystemChecks
Description: Executes system checks including sending low stock alerts
             and payment reminders.
Parameters: None
Return type: void
*/
void Controller::runSystemChecks()
{
    m_userManagementService.ensureAdminExists();
    m_inventoryManagementService.sendLowStockAlerts();
    m_paymentManagementService.sendPaymentReminders();
}