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

/*
File: Controller.cpp
Description: Implementation file containing the method definitions of the
             Controller class, including authentication, user creation,
             service purchasing, and system checks.
Author: Trenser
Date:19-May-2026
*/
#include <stdexcept>
#include "Controller.h"
#include "Enums.h"
#include "User.h"

/*
Function: login
Description: Authenticates a user by delegating to the authentication management service.
Parameter: const std::string& username - user’s username
           const std::string& password - user’s password
Return type: bool - true if login successful, false otherwise
*/
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.
Parameter: None
Return type: void
*/
void Controller::logout()
{
    m_authenticationManagementService.logout();
}

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

/*
Function: createCustomer
Description: Creates a new customer account with the provided details.
Parameter: const std::string& username - customer’s username
           const std::string& name - customer’s name
           const std::string& password - customer’s password
           const std::string& email - customer’s email
           const std::string& phone - customer’s phone number
Return type: void
*/

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);
}

/*
Function: getAuthenticatedUser
Description: Retrieves the currently authenticated user.
Parameter: None
Return type: const User* - pointer to the authenticated user
*/
const User* Controller::getAuthenticatedUser()
{
    return m_authenticationManagementService.getAuthenticatedUser();
}

void Controller::createTechnician(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone)
{
}

/*
Function: updateUserDetails
Description: Updates the email and phone details of the currently authenticated user.
Parameter: const std::string& email - new email address
           const std::string& phone - new phone number
Return type: void
*/
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()
{
    return util::Map<std::string, const Service*>();
}

util::Map<std::string, const ComboPackage*> Controller::getComboPackages()
{
    return util::Map<std::string, const ComboPackage*>();
}

/*
Function: purchaseService
Description: Purchases one or more services for a vehicle by delegating to the service management service.
Parameter: const util::Vector<std::string>& serviceIDs - IDs of services to purchase
           const std::string& vehicleNumber - vehicle registration number
           const std::string& vehicleBrand - brand of the vehicle
           const std::string& vehicleModel - model of the vehicle
Return type: void
*/
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);
}

/*
Function: purchaseComboPackage
Description: Purchases a combo package for a vehicle by delegating to the service management service.
Parameter: const std::string& comboPackageID - ID of the combo package
           const std::string& vehicleNumber - vehicle registration number
           const std::string& vehicleBrand - brand of the vehicle
           const std::string& vehicleModel - model of the vehicle
Return type: void
*/
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);
}

util::Map<std::string, const InventoryItem*> Controller::getInventoryItems()
{
    return util::Map<std::string, const InventoryItem*>();
}

const InventoryItem* Controller::getInventoryItem(const std::string& inventoryItemID)
{
    return nullptr;
}

void Controller::addInventoryItem(const std::string& partName, int quantity, double price)
{
}

void Controller::removeInventoryItem(const std::string& inventoryItemID)
{
}

util::Map<std::string, const ServiceBooking*> Controller::getServiceBookings()
{
    return util::Map<std::string, const ServiceBooking*>();
}

util::Map<std::string, const ServiceBooking*> Controller::getServiceBookingsByUser(const std::string userID)
{
    return util::Map<std::string, const ServiceBooking*>();
}

util::Map<std::string, const User*> Controller::getUsers()
{
    return util::Map<std::string, const User*>();
}

util::Map<std::string, const User*> Controller::getUsers(util::UserType userType)
{
    return util::Map<std::string, const User*>();
}

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

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

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

util::Map<std::string, const JobCard*> Controller::getJobCardsByUser()
{
    return util::Map<std::string, const JobCard*>();
}

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

void Controller::removeUser(const std::string& userID)
{
}

void Controller::createComboPackage(const std::string& name, const util::Vector<std::string>& serviceIDs, double discountPercentage)
{
}

void Controller::removeComboPackage(const std::string& comboPackageID)
{
}

util::Map<std::string, const Invoice*> Controller::getInvoicesByUser()
{
    return util::Map<std::string, const Invoice*>();
}

void Controller::completePayment(const std::string& invoiceID, util::PaymentMode 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: loadSystemData
Description: Loads all system data from persistent storage into memory.
             Invokes the respective management services to load users, inventory items, services,
             combo packages, service bookings, job cards, invoices, and observers.
Parameters:
    - None
Returns:
    - void
*/
void Controller::loadSystemData()
{
    m_userManagementService.loadUsers();
    m_inventoryManagementService.loadInventoryItems();
    m_serviceManagementService.loadServices();
    m_serviceManagementService.loadComboPackages();
    m_serviceManagementService.loadServiceBookings();
    m_serviceManagementService.loadJobCards();
    m_paymentManagementService.loadInvoices();
    m_serviceManagementService.loadObservers();
    m_paymentManagementService.loadObservers();
    m_inventoryManagementService.loadObservers();
}

/*
Function: saveSystemData
Description: Saves all system data from memory back to persistent storage.
             Invokes the respective management services to save users, inventory items, services,
             combo packages, service bookings, job cards, invoices, and observers.
Parameters:
    - None
Returns:
    - void
*/
void Controller::saveSystemData()
{
    m_userManagementService.saveUsers();
    m_inventoryManagementService.saveInventoryItems();
    m_serviceManagementService.saveServices();
    m_serviceManagementService.saveComboPackages();
    m_serviceManagementService.saveServiceBookings();
    m_serviceManagementService.saveJobCards();
    m_paymentManagementService.saveInvoices();
    m_serviceManagementService.saveObservers();
    m_paymentManagementService.saveObservers();
    m_inventoryManagementService.saveObservers();
}

/*
Function: runSystemChecks
Description: Runs system checks to ensure critical configurations, such as verifying admin existence.
Parameter: None
Return type: void
*/
void Controller::runSystemChecks()
{
    m_userManagementService.ensureAdminExists();
    m_inventoryManagementService.sendLowStockAlerts();
    m_paymentManagementService.sendPaymentReminders();
}