Add documentation headers across system modules

<UserStory> NOT001: View Customer Notifications </UserStory>

<Changes>
1. Added shared notification helper functions to display notifications in tabular format, support notification selection, and show full notification details.
2. Implemented notification deletion logic in Controller and UserManagementService to remove notifications for the authenticated user after viewing.
3. Updated CustomerMenu::viewNotifications() to use the shared notification viewing and deletion flow.
</Changes>

<Test>

Precondition:
1. Customer is registered in the system.
2. Customer is logged into the system.
3. Customer has one or more notifications available.

Steps:
1. Navigate to “View Notifications” from the customer menu.
- Verify that the system displays the list of notifications with title and timestamp.

2. Select a notification from the displayed list.
   - Verify that the system displays the full notification details including message.

3. View the selected notification and continue.
   - Verify that the viewed notification is deleted from the system.

4. Navigate to “View Notifications” again.
   - Verify that the previously viewed notification no longer appears in the notification list.

</Test>

<Review>
Sreeja Reghukumar, please review
</Review>

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem.cpp

@@ -1,5 +1,22 @@
+/*
+File: Trenser.VehicleServiceSystem.cpp
+Description: Entry point for the Vehicle Service Management System.
+			 Initializes the UserInterface and starts the application loop.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #include "UserInterface.h"
 
+/*
+Function: main
+Description: The main entry point of the application.
+			 Creates a UserInterface object and invokes the run method to start the system.
+Parameters:
+	- None
+Returns:
+	- int: Exit status code (0 for successful execution).
+*/
 int main()
 {
 	UserInterface userInterface;

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem.vcxproj

@@ -171,6 +171,7 @@
     <ClInclude Include="services\PaymentManagementService.h" />
     <ClInclude Include="services\ServiceManagementService.h" />
     <ClInclude Include="services\UserManagementService.h" />
+    <ClInclude Include="utilities\Config.h" />
     <ClInclude Include="utilities\Enums.h" />
     <ClInclude Include="utilities\InputHelper.h" />
     <ClInclude Include="utilities\Map.h" />
@@ -181,6 +182,7 @@
     <ClInclude Include="utilities\Vector.h" />
     <ClInclude Include="views\AdminMenu.h" />
     <ClInclude Include="views\CustomerMenu.h" />
+    <ClInclude Include="views\MenuHelper.h" />
     <ClInclude Include="views\TechnicianMenu.h" />
     <ClInclude Include="views\UserInterface.h" />
   </ItemGroup>

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem.vcxproj.filters

@@ -233,8 +233,8 @@
     <ClInclude Include="models\ComboPackage.h">
       <Filter>Header Files\Models</Filter>
     </ClInclude>
-    <ClInclude Include="utilities\Utility.h">
+    <ClInclude Include="views\MenuHelper.h">
-      <Filter>Header Files\Utilities</Filter>
+      <Filter>Header Files\Views</Filter>
     </ClInclude>
   </ItemGroup>
 </Project>

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/controllers/Controller.cpp

@@ -1,13 +1,12 @@
 /*
 File: Controller.cpp
-Description: Implementation file containing the method definitions of the
+Description: Implements the Controller class which manages authentication, user, service, inventory, payment, and notification operations in the Vehicle Service Management System.
-             Controller class, which manages authentication, users, services,
-             combo packages, and inventory operations.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
+
+#include <stdexcept>
 #include "Controller.h"
-#include "ComboPackage.h"
 #include "User.h"
 
 bool Controller::login(const std::string& username, const std::string& password)
@@ -15,28 +14,12 @@ bool Controller::login(const std::string& username, const std::string& password)
     return false;
 }
 
-/*
-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& password, const std::string& email, const std::string& phone)
@@ -48,19 +31,8 @@ const User* Controller::getAuthenticatedUser()
     return nullptr;
 }
 
-/*
+void Controller::createTechnician(const std::string& username, const std::string& password, const std::string& email, const std::string& phone)
-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)
@@ -72,26 +44,9 @@ util::Map<std::string, const Service*> Controller::getServices()
     return util::Map<std::string, const Service*>();
 }
 
-/*
-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();
+    return util::Map<std::string, const ComboPackage*>();
-    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)
@@ -130,22 +85,9 @@ util::Map<std::string, const ServiceBooking*> Controller::getServiceBookingsByUs
     return util::Map<std::string, const ServiceBooking*>();
 }
 
-/*
-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();
+    return util::Map<std::string, const User*>();
-    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)
@@ -174,49 +116,16 @@ void Controller::completeJob(const std::string& 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()
@@ -228,20 +137,94 @@ void Controller::completePayment(const std::string& invoiceID, util::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()
 {
-    return util::Vector<const Notification*>();
+    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());
 }
 
-void Controller::configureNotifications(const std::string& userID, bool paymentNotifications, bool serviceNotifications)
+/*
+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_inventoryManagementService.sendLowStockAlerts();
+    m_paymentManagementService.sendPaymentReminders();
 }
 

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/controllers/Controller.h

@@ -1,18 +1,19 @@
 /*
 File: Controller.h
-Description: Header file declaring the Controller class, which manages
+Description: File contains the Controller class which manages authentication, user, service, inventory, payment, and notification operations in the Vehicle Service Management System.
-             user authentication, inventory, services, bookings, job cards,
-             invoices, and notifications in the system.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
+
 #pragma once
-#include <string>
 #include "Map.h"
+#include <string>
 #include "Enums.h"
-#include "UserManagementService.h"
-#include "ServiceManagementService.h"
 #include "AuthenticationManagementService.h"
+#include "ServiceManagementService.h"
+#include "UserManagementService.h"
+#include "InventoryManagementService.h"
+#include "PaymentManagementService.h"
 
 class Service;
 class ComboPackage;
@@ -28,6 +29,8 @@ class Controller
 private:
     AuthenticationManagementService m_authenticationManagementService;
     UserManagementService m_userManagementService;
+    InventoryManagementService m_inventoryManagementService;
+    PaymentManagementService m_paymentManagementService;
     ServiceManagementService m_serviceManagementService;
 public:
     bool login(const std::string& username, const std::string& password);
@@ -35,7 +38,7 @@ public:
     void changePassword(const std::string& newPassword);
     void createCustomer(const std::string& username, const std::string& password, const std::string& email, const std::string& phone);
     const User* getAuthenticatedUser();
-    void createTechnician(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phoneNumber);
+    void createTechnician(const std::string& username, const std::string& password, const std::string& email, const std::string& phone);
     void updateUserDetails(const std::string& email, const std::string& phone);
     util::Map<std::string, const Service*> getServices();
     util::Map<std::string, const ComboPackage*> getComboPackages();
@@ -61,6 +64,6 @@ public:
     void completePayment(const std::string& invoiceID, util::PaymentMode paymentMode);
     util::Vector<const Notification*> getNotifications();
     void deleteNotification(const std::string& notificationID);
-    void configureNotifications(const std::string& userID, bool paymentNotifications, bool serviceNotifications);
+    void configureNotifications(bool paymentNotifications, bool serviceNotifications);
     void runSystemChecks();
 };

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/core/patterns/Observer.h

@@ -1,3 +1,10 @@
+/*
+File: Observer.h
+Description: Declares the Observer interface for handling notifications in the Vehicle Service Management System.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #pragma once
 
 class Notification;
@@ -6,5 +13,5 @@ class Observer
 {
 public:
     virtual ~Observer() = default;
-    virtual void update(Notification* notification) = 0;
+    virtual void addNotification(Notification* notification) = 0;
 };

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/core/patterns/Subject.h

@@ -1,3 +1,10 @@
+/*
+File: Subject.h
+Description: Declares the Subject interface for managing user attachments and detachments in the Observer design pattern within the Vehicle Service Management System.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #pragma once
 #include <string>
 #include "Map.h"

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/datastores/DataStore.cpp

@@ -1,46 +1,128 @@
+/*
+File: DataStore.cpp
+Description: Implements the DataStore class which provides a centralized singleton repository
+             for managing system data in the Vehicle Service Management System.
+             Includes accessors for users, services, combo packages, service bookings,
+             job cards, inventory items, invoices, and payments.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #include "DataStore.h"
 
+/*
+Function: getInstance
+Description: Provides a singleton instance of the DataStore class.
+Parameters:
+    - None
+Returns:
+    - Reference to the single DataStore instance.
+*/
 DataStore& DataStore::getInstance()
 {
     static DataStore dataStore;
     return dataStore;
 }
 
+/*
+Function: getUsers
+Description: Retrieves the internal map of users.
+Parameters:
+    - None
+Returns:
+    - Reference to util::Map<std::string, User*> containing all users.
+*/
 util::Map<std::string, User*>& DataStore::getUsers()
 {
     return m_users;
 }
 
+/*
+Function: getServices
+Description: Retrieves the internal map of services.
+Parameters:
+    - None
+Returns:
+    - Reference to util::Map<std::string, Service*> containing all services.
+*/
 util::Map<std::string, Service*>& DataStore::getServices()
 {
     return m_services;
 }
 
+/*
+Function: getComboPackages
+Description: Retrieves the internal map of combo packages.
+Parameters:
+    - None
+Returns:
+    - Reference to util::Map<std::string, ComboPackage*> containing all combo packages.
+*/
 util::Map<std::string, ComboPackage*>& DataStore::getComboPackages()
 {
     return m_comboPackages;
 }
 
+/*
+Function: getServiceBookings
+Description: Retrieves the internal map of service bookings.
+Parameters:
+    - None
+Returns:
+    - Reference to util::Map<std::string, ServiceBooking*> containing all service bookings.
+*/
 util::Map<std::string, ServiceBooking*>& DataStore::getServiceBookings()
 {
     return m_serviceBookings;
 }
 
+/*
+Function: getJobCards
+Description: Retrieves the internal map of job cards.
+Parameters:
+    - None
+Returns:
+    - Reference to util::Map<std::string, JobCard*> containing all job cards.
+*/
 util::Map<std::string, JobCard*>& DataStore::getJobCards()
 {
     return m_jobCards;
 }
 
+/*
+Function: getInventoryItems
+Description: Retrieves the internal map of inventory items.
+Parameters:
+    - None
+Returns:
+    - Reference to util::Map<std::string, InventoryItem*> containing all inventory items.
+*/
 util::Map<std::string, InventoryItem*>& DataStore::getInventoryItems()
 {
     return m_inventoryItems;
 }
 
+/*
+Function: getInvoices
+Description: Retrieves the internal map of invoices.
+Parameters:
+    - None
+Returns:
+    - Reference to util::Map<std::string, Invoice*> containing all invoices.
+*/
 util::Map<std::string, Invoice*>& DataStore::getInvoices()
 {
     return m_invoices;
 }
 
+/*
+Function: getPayments
+Description: Retrieves the internal map of payments.
+Parameters:
+    - None
+Returns:
+    - Reference to util::Map<std::string, Payment*> containing all payments.
+*/
 util::Map<std::string, Payment*>& DataStore::getPayments()
 {
     return m_payments;

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/datastores/DataStore.h

@@ -1,5 +1,11 @@
-#pragma once
+/*
+File: DataStore.h
+Description: Declares the DataStore singleton class responsible for managing collections of users, services, combo packages, service bookings, job cards, inventory items, invoices, and payments in the Vehicle Service Management System.
+Author: Trenser
+Date: 19-May-2026
+*/
 
+#pragma once
 #include <string>
 #include "Map.h"
 

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/ComboPackage.cpp

@@ -1,12 +1,41 @@
+/*
+File: ComboPackage.cpp
+Description: Implements the ComboPackage class which represents a bundled set of services in the Vehicle Service Management System.
+             Provides constructors, accessors, and mutators for package details such as ID, name, discount percentage, state,
+             and associated services.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #include "ComboPackage.h"
 
 int ComboPackage::m_uid = 0;
 
+/*
+Function: ComboPackage
+Description: Default constructor that initializes a new combo package with a unique ID,
+             active state, and zero discount percentage.
+Parameters:
+    - None
+Returns:
+    - A new ComboPackage object.
+*/
 ComboPackage::ComboPackage()
     : m_id("CMP" + std::to_string(++m_uid)),
     m_status(util::State::ACTIVE),
     m_discountPercentage(0.0) {}
 
+/*
+Function: ComboPackage
+Description: Parameterized constructor that initializes a new combo package with a unique ID,
+             specified package name, discount percentage, active state, and associated services.
+Parameters:
+    - packageName: Name of the combo package.
+    - discountPercentage: Discount percentage applied to the package.
+    - services: Map of services included in the package.
+Returns:
+    - A new ComboPackage object.
+*/
 ComboPackage::ComboPackage(const std::string& packageName, double discountPercentage, const util::Map<std::string, Service*>& services)
     : m_id("CMP" + std::to_string(++m_uid)),
     m_packageName(packageName),
@@ -14,51 +43,131 @@ ComboPackage::ComboPackage(const std::string& packageName, double discountPercen
     m_status(util::State::ACTIVE),
     m_services(services) {}
 
+/*
+Function: getId
+Description: Retrieves the unique ID of the combo package.
+Parameters:
+    - None
+Returns:
+    - const std::string& representing the package ID.
+*/
 const std::string& ComboPackage::getId() const
 {
     return m_id;
 }
 
+/*
+Function: getPackageName
+Description: Retrieves the name of the combo package.
+Parameters:
+    - None
+Returns:
+    - const std::string& representing the package name.
+*/
 const std::string& ComboPackage::getPackageName() const
 {
     return m_packageName;
 }
 
+/*
+Function: getDiscountPercentage
+Description: Retrieves the discount percentage applied to the combo package.
+Parameters:
+    - None
+Returns:
+    - double representing the discount percentage.
+*/
 double ComboPackage::getDiscountPercentage() const
 {
     return m_discountPercentage;
 }
 
+/*
+Function: getState
+Description: Retrieves the current state (ACTIVE/INACTIVE) of the combo package.
+Parameters:
+    - None
+Returns:
+    - util::State representing the package state.
+*/
 util::State ComboPackage::getState() const
 {
     return m_status;
 }
 
+/*
+Function: getServices
+Description: Retrieves the map of services included in the combo package.
+Parameters:
+    - None
+Returns:
+    - const util::Map<std::string, Service*>& representing the services.
+*/
 const util::Map<std::string, Service*>& ComboPackage::getServices() const
 {
     return m_services;
 }
 
+/*
+Function: setId
+Description: Sets the unique ID of the combo package.
+Parameters:
+    - id: New ID string.
+Returns:
+    - void
+*/
 void ComboPackage::setId(const std::string& id)
 {
     m_id = id;
 }
 
+/*
+Function: setPackageName
+Description: Sets the name of the combo package.
+Parameters:
+    - packageName: New package name string.
+Returns:
+    - void
+*/
 void ComboPackage::setPackageName(const std::string& packageName)
 {
     m_packageName = packageName;
 }
 
+/*
+Function: setDiscountPercentage
+Description: Sets the discount percentage for the combo package.
+Parameters:
+    - discountPercentage: New discount percentage value.
+Returns:
+    - void
+*/
 void ComboPackage::setDiscountPercentage(double discountPercentage)
 {
     m_discountPercentage = discountPercentage;
 }
 
+/*
+Function: setServices
+Description: Sets the services included in the combo package.
+Parameters:
+    - services: Map of services to be associated with the package.
+Returns:
+    - void
+*/
 void ComboPackage::setServices(const util::Map<std::string, Service*>& services)
 {
     m_services = services;
 }
 
+/*
+Function: setState
+Description: Sets the state (ACTIVE/INACTIVE) of the combo package.
+Parameters:
+    - status: New state value.
+Returns:
+    - void
+*/
 void ComboPackage::setState(util::State status)
 {
     m_status = status;

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/ComboPackage.h

@@ -1,3 +1,10 @@
+/*
+File: ComboPackage.h
+Description: Declares the ComboPackage class which represents a service package with a unique ID, package name, discount percentage, associated services, and status in the Vehicle Service Management System.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #pragma once
 #include <string>
 #include "Map.h"

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/InventoryItem.cpp

@@ -1,13 +1,41 @@
+/*
+File: InventoryItem.cpp
+Description: Implements the InventoryItem class which represents an inventory item in the Vehicle Service Management System.
+             Provides constructors, accessors, and mutators for item details such as ID, part name, quantity, price, and state.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #include "InventoryItem.h"
 
 int InventoryItem::m_uid = 0;
 
+/*
+Function: InventoryItem
+Description: Default constructor that initializes a new inventory item with a unique ID,
+             active state, zero quantity, and zero price.
+Parameters:
+    - None
+Returns:
+    - A new InventoryItem object.
+*/
 InventoryItem::InventoryItem()
     : m_id("IIM" + std::to_string(++m_uid)),
     m_quantity(0),
     m_status(util::State::ACTIVE),
     m_price(0.0) {}
 
+/*
+Function: InventoryItem
+Description: Parameterized constructor that initializes a new inventory item with a unique ID,
+             specified part name, quantity, price, and active state.
+Parameters:
+    - partName: Name of the inventory item.
+    - quantity: Initial quantity of the item.
+    - price: Price of the item.
+Returns:
+    - A new InventoryItem object.
+*/
 InventoryItem::InventoryItem(const std::string& partName, int quantity, double price)
     : m_id("IIM" + std::to_string(++m_uid)),
     m_partName(partName),
@@ -15,51 +43,131 @@ InventoryItem::InventoryItem(const std::string& partName, int quantity, double p
     m_status(util::State::ACTIVE),
     m_price(price) {}
 
+/*
+Function: getId
+Description: Retrieves the unique ID of the inventory item.
+Parameters:
+    - None
+Returns:
+    - const std::string& representing the item ID.
+*/
 const std::string& InventoryItem::getId() const
 {
     return m_id;
 }
 
+/*
+Function: getPartName
+Description: Retrieves the part name of the inventory item.
+Parameters:
+    - None
+Returns:
+    - const std::string& representing the part name.
+*/
 const std::string& InventoryItem::getPartName() const
 {
     return m_partName;
 }
 
+/*
+Function: getQuantity
+Description: Retrieves the current quantity of the inventory item.
+Parameters:
+    - None
+Returns:
+    - int representing the quantity.
+*/
 int InventoryItem::getQuantity() const
 {
     return m_quantity;
 }
 
+/*
+Function: getPrice
+Description: Retrieves the price of the inventory item.
+Parameters:
+    - None
+Returns:
+    - double representing the price.
+*/
 double InventoryItem::getPrice() const
 {
     return m_price;
 }
 
+/*
+Function: getState
+Description: Retrieves the current state (ACTIVE/INACTIVE) of the inventory item.
+Parameters:
+    - None
+Returns:
+    - util::State representing the item state.
+*/
 util::State InventoryItem::getState() const
 {
     return m_status;
 }
 
+/*
+Function: setId
+Description: Sets the unique ID of the inventory item.
+Parameters:
+    - id: New ID string.
+Returns:
+    - void
+*/
 void InventoryItem::setId(const std::string& id)
 {
     m_id = id;
 }
 
+/*
+Function: setPartName
+Description: Sets the part name of the inventory item.
+Parameters:
+    - partName: New part name string.
+Returns:
+    - void
+*/
 void InventoryItem::setPartName(const std::string& partName)
 {
     m_partName = partName;
 }
 
+/*
+Function: setQuantity
+Description: Sets the quantity of the inventory item.
+Parameters:
+    - quantity: New quantity value.
+Returns:
+    - void
+*/
 void InventoryItem::setQuantity(int quantity)
 {
     m_quantity = quantity;
 }
 
+/*
+Function: setPrice
+Description: Sets the price of the inventory item.
+Parameters:
+    - price: New price value.
+Returns:
+    - void
+*/
 void InventoryItem::setPrice(double price)
 {
     m_price = price;
 }
 
+/*
+Function: setState
+Description: Sets the state (ACTIVE/INACTIVE) of the inventory item.
+Parameters:
+    - status: New state value.
+Returns:
+    - void
+*/
 void InventoryItem::setState(util::State status)
 {
     m_status = status;

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/InventoryItem.h

@@ -1,3 +1,12 @@
+/*
+File: InventoryItem.h
+Description: Declares the InventoryItem class which represents parts in the Vehicle Service Management System.
+             Each item has a unique ID, part name, quantity, price, and status.
+Author: Trenser
+Date: 19-May-2026
+*/
+
+
 #pragma once
 #include <string>
 #include "Enums.h"

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/Invoice.cpp

@@ -1,7 +1,26 @@
+/*
+File: Invoice.cpp
+Description: Implements the Invoice class which represents an invoice in the Vehicle Service Management System.
+             Provides constructors, accessors, and mutators for invoice details such as ID, booking, costs,
+             discount percentage, total amount, payment details, and status.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #include "Invoice.h"
 
 int Invoice::m_uid = 0;
 
+/*
+Function: Invoice
+Description: Default constructor that initializes a new invoice with a unique ID,
+             null booking, zero costs, zero discount, zero total amount,
+             and default payment method and status.
+Parameters:
+    - None
+Returns:
+    - A new Invoice object.
+*/
 Invoice::Invoice()
     : m_id("INV" + std::to_string(++m_uid)),
     m_booking(nullptr),
@@ -12,6 +31,24 @@ Invoice::Invoice()
     m_paymentMethod(util::PaymentMode()),
     m_status(util::PaymentStatus()) {}
 
+/*
+Function: Invoice
+Description: Parameterized constructor that initializes a new invoice with a unique ID and specified details.
+Parameters:
+    - bookingId: ID of the associated service booking.
+    - booking: Pointer to the ServiceBooking object.
+    - invoiceDate: Timestamp of when the invoice was created.
+    - laborCost: Cost of labor for the service.
+    - parts: Map of inventory items used in the service.
+    - partsCost: Total cost of parts.
+    - discountPercentage: Discount applied to the invoice.
+    - totalAmount: Final total amount after discount.
+    - paymentDate: Timestamp of when payment was made.
+    - paymentMethod: Payment mode (ONLINE/OFFLINE).
+    - status: Payment status (PENDING/COMPLETED).
+Returns:
+    - A new Invoice object.
+*/
 Invoice::Invoice(
     const std::string& bookingId,
     ServiceBooking* booking,
@@ -38,121 +75,289 @@ Invoice::Invoice(
     m_paymentMethod(paymentMethod),
     m_status(status) {}
 
+/*
+Function: getId
+Description: Retrieves the unique ID of the invoice.
+Returns:
+    - const std::string& representing the invoice ID.
+*/
 const std::string& Invoice::getId() const
 {
     return m_id;
 }
 
+/*
+Function: getBookingId
+Description: Retrieves the booking ID associated with the invoice.
+Returns:
+    - const std::string& representing the booking ID.
+*/
 const std::string& Invoice::getBookingId() const
 {
     return m_bookingId;
 }
 
+/*
+Function: getBooking
+Description: Retrieves the pointer to the associated ServiceBooking.
+Returns:
+    - ServiceBooking* representing the booking.
+*/
 ServiceBooking* Invoice::getBooking() const
 {
     return m_booking;
 }
 
+/*
+Function: getInvoiceDate
+Description: Retrieves the timestamp of the invoice creation date.
+Returns:
+    - const util::Timestamp& representing the invoice date.
+*/
 const util::Timestamp& Invoice::getInvoiceDate() const
 {
     return m_invoiceDate;
 }
 
+/*
+Function: getLaborCost
+Description: Retrieves the labor cost associated with the invoice.
+Returns:
+    - double representing the labor cost.
+*/
 double Invoice::getLaborCost() const
 {
     return m_laborCost;
 }
 
+/*
+Function: getParts
+Description: Retrieves the map of inventory items used in the service.
+Returns:
+    - const util::Map<int, InventoryItem*>& representing the parts.
+*/
 const util::Map<int, InventoryItem*>& Invoice::getParts() const
 {
     return m_parts;
 }
 
+/*
+Function: getPartsCost
+Description: Retrieves the total cost of parts used in the service.
+Returns:
+    - double representing the parts cost.
+*/
 double Invoice::getPartsCost() const
 {
     return m_partsCost;
 }
 
+/*
+Function: getDiscountPercentage
+Description: Retrieves the discount percentage applied to the invoice.
+Returns:
+    - double representing the discount percentage.
+*/
 double Invoice::getDiscountPercentage() const
 {
     return m_discountPercentage;
 }
 
+/*
+Function: getTotalAmount
+Description: Retrieves the total amount of the invoice after discount.
+Returns:
+    - double representing the total amount.
+*/
 double Invoice::getTotalAmount() const
 {
     return m_totalAmount;
 }
 
+/*
+Function: getPaymentDate
+Description: Retrieves the timestamp of the payment date.
+Returns:
+    - const util::Timestamp& representing the payment date.
+*/
 const util::Timestamp& Invoice::getPaymentDate() const
 {
     return m_paymentDate;
 }
 
+/*
+Function: getPaymentMethod
+Description: Retrieves the payment mode used for the invoice.
+Returns:
+    - util::PaymentMode representing the payment method.
+*/
 util::PaymentMode Invoice::getPaymentMethod() const
 {
     return m_paymentMethod;
 }
 
+/*
+Function: getStatus
+Description: Retrieves the payment status of the invoice.
+Returns:
+    - util::PaymentStatus representing the payment status.
+*/
 util::PaymentStatus Invoice::getStatus() const
 {
     return m_status;
 }
 
+/*
+Function: setId
+Description: Sets the unique ID of the invoice.
+Parameters:
+    - id: New invoice ID string.
+Returns:
+    - void
+*/
 void Invoice::setId(const std::string& id)
 {
     m_id = id;
 }
 
+/*
+Function: setBookingId
+Description: Sets the booking ID associated with the invoice.
+Parameters:
+    - bookingId: New booking ID string.
+Returns:
+    - void
+*/
 void Invoice::setBookingId(const std::string& bookingId)
 {
     m_bookingId = bookingId;
 }
 
+/*
+Function: setBooking
+Description: Sets the associated ServiceBooking pointer.
+Parameters:
+    - booking: Pointer to the ServiceBooking object.
+Returns:
+    - void
+*/
 void Invoice::setBooking(ServiceBooking* booking)
 {
     m_booking = booking;
 }
 
+/*
+Function: setInvoiceDate
+Description: Sets the invoice creation date.
+Parameters:
+    - invoiceDate: New timestamp for the invoice date.
+Returns:
+    - void
+*/
 void Invoice::setInvoiceDate(const util::Timestamp& invoiceDate)
 {
     m_invoiceDate = invoiceDate;
 }
 
+/*
+Function: setLaborCost
+Description: Sets the labor cost for the invoice.
+Parameters:
+    - laborCost: New labor cost value.
+Returns:
+    - void
+*/
 void Invoice::setLaborCost(double laborCost)
 {
     m_laborCost = laborCost;
 }
 
+/*
+Function: setParts
+Description: Sets the inventory items used in the service.
+Parameters:
+    - parts: Map of inventory items.
+Returns:
+    - void
+*/
 void Invoice::setParts(const util::Map<int, InventoryItem*>& parts)
 {
     m_parts = parts;
 }
 
+/*
+Function: setPartsCost
+Description: Sets the total cost of parts used in the service.
+Parameters:
+    - partsCost: New parts cost value.
+Returns:
+    - void
+*/
 void Invoice::setPartsCost(double partsCost)
 {
     m_partsCost = partsCost;
 }
 
+/*
+Function: setDiscountPercentage
+Description: Sets the discount percentage applied to the invoice.
+Parameters:
+    - discountPercentage: New discount percentage value.
+Returns:
+    - void
+*/
 void Invoice::setDiscountPercentage(double discountPercentage)
 {
     m_discountPercentage = discountPercentage;
 }
 
+/*
+Function: setTotalAmount
+Description: Sets the total amount of the invoice.
+Parameters:
+    - totalAmount: New total amount value.
+Returns:
+    - void
+*/
 void Invoice::setTotalAmount(double totalAmount)
 {
     m_totalAmount = totalAmount;
 }
 
+/*
+Function: setPaymentDate
+Description: Sets the payment date for the invoice.
+Parameters:
+    - paymentDate: New timestamp for the payment date.
+Returns:
+    - void
+*/
 void Invoice::setPaymentDate(const util::Timestamp& paymentDate)
 {
     m_paymentDate = paymentDate;
 }
 
+/*
+Function: setPaymentMethod
+Description: Sets the payment mode for the invoice.
+Parameters:
+    - paymentMethod: New payment mode value.
+Returns:
+    - void
+*/
 void Invoice::setPaymentMethod(util::PaymentMode paymentMethod)
 {
     m_paymentMethod = paymentMethod;
 }
 
+/*
+Function: setStatus
+Description: Sets the payment status of the invoice.
+Parameters:
+    - status: New payment status value.
+Returns:
+    - void
+*/
 void Invoice::setStatus(util::PaymentStatus status)
 {
     m_status = status;

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/Invoice.h

@@ -1,3 +1,12 @@
+/*
+File: Invoice.h
+Description: Declares the Invoice class which represents billing details for a service booking in the Vehicle Service Management System.
+             Each invoice includes booking information, labor cost, parts used, discount percentage, total amount, payment details, and status.
+Author: Trenser
+Date: 19-May-2026
+*/
+
+
 #pragma once
 #include <string>
 #include "Map.h"

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/JobCard.cpp

@@ -1,43 +1,47 @@
 /*
 File: JobCard.cpp
-Description: Implementation file containing the method definitions of the
+Description: Implements the JobCard class which represents a technician’s job assignment in the Vehicle Service Management System.
-             JobCard class, including constructors, getters, and setters
+             Provides constructors, accessors, and mutators for job details such as ID, booking, service, technician,
-             for job card attributes.
+             assigned date, completion date, and job status.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
+
 #include "JobCard.h"
 
 int JobCard::m_uid = 0;
 
 /*
 Function: JobCard
-Description: Default constructor that initializes a new job card with
+Description: Default constructor that initializes a new job card with a unique ID,
-             a unique ID and default values.
+             null booking, null service, null technician, and default job status.
-Parameter: None
+Parameters:
-Return type: Constructor
+    - None
+Returns:
+    - A new JobCard object.
 */
 JobCard::JobCard()
     : m_id("JC" + std::to_string(++m_uid)),
     m_booking(nullptr),
     m_service(nullptr),
     m_technician(nullptr),
-    m_status(util::ServiceJobStatus()) {}
+    m_status(ServiceJobStatus()) {}
 
 /*
 Function: JobCard
-Description: Parameterized constructor that initializes a job card with
+Description: Parameterized constructor that initializes a new job card with a unique ID and specified details.
-             booking, service, technician, and status details.
+Parameters:
-Parameter: const std::string& bookingId - ID of the booking
+    - bookingId: ID of the associated service booking.
-           ServiceBooking* booking - pointer to the booking object
+    - booking: Pointer to the ServiceBooking object.
-           Service* service - pointer to the service object
+    - service: Pointer to the Service object.
-           const std::string& serviceId - ID of the service
+    - serviceId: ID of the associated service.
-           const std::string& technicianId - ID of the technician
+    - technicianId: ID of the assigned technician.
-           User* technician - pointer to the technician object
+    - technician: Pointer to the User object representing the technician.
-           const util::Timestamp& assignedDate - date when job was assigned
+    - assignedDate: Timestamp of when the job was assigned.
-           util::ServiceJobStatus status - current status of the job
+    - status: Current status of the job (STARTED/COMPLETED).
-           const util::Timestamp& completionDate - date when job was completed
+    - completionDate: Timestamp of when the job was completed.
-Return type: Constructor
+Returns:
+    - A new JobCard object.
 */
 JobCard::JobCard(const std::string& bookingId,
     ServiceBooking* booking,
@@ -46,7 +50,7 @@ JobCard::JobCard(const std::string& bookingId,
     const std::string& technicianId,
     User* technician,
     const util::Timestamp& assignedDate,
-    util::ServiceJobStatus status,
+    ServiceJobStatus status,
     const util::Timestamp& completionDate
 )
     : m_id("JC" + std::to_string(++m_uid)),
@@ -62,9 +66,9 @@ JobCard::JobCard(const std::string& bookingId,
 
 /*
 Function: getId
-Description: Retrieves the unique identifier of the job card.
+Description: Retrieves the unique ID of the job card.
-Parameter: None
+Returns:
-Return type: const std::string&
+    - const std::string& representing the job card ID.
 */
 const std::string& JobCard::getId() const
 {
@@ -74,8 +78,8 @@ const std::string& JobCard::getId() const
 /*
 Function: getBookingId
 Description: Retrieves the booking ID associated with the job card.
-Parameter: None
+Returns:
-Return type: const std::string&
+    - const std::string& representing the booking ID.
 */
 const std::string& JobCard::getBookingId() const
 {
@@ -84,9 +88,9 @@ const std::string& JobCard::getBookingId() const
 
 /*
 Function: getBooking
-Description: Retrieves the booking object associated with the job card.
+Description: Retrieves the pointer to the associated ServiceBooking.
-Parameter: None
+Returns:
-Return type: ServiceBooking*
+    - ServiceBooking* representing the booking.
 */
 ServiceBooking* JobCard::getBooking() const
 {
@@ -95,9 +99,9 @@ ServiceBooking* JobCard::getBooking() const
 
 /*
 Function: getService
-Description: Retrieves the service object associated with the job card.
+Description: Retrieves the pointer to the associated Service.
-Parameter: None
+Returns:
-Return type: Service*
+    - Service* representing the service.
 */
 Service* JobCard::getService() const
 {
@@ -107,8 +111,8 @@ Service* JobCard::getService() const
 /*
 Function: getServiceId
 Description: Retrieves the service ID associated with the job card.
-Parameter: None
+Returns:
-Return type: const std::string&
+    - const std::string& representing the service ID.
 */
 const std::string& JobCard::getServiceId() const
 {
@@ -117,9 +121,9 @@ const std::string& JobCard::getServiceId() const
 
 /*
 Function: getTechnicianId
-Description: Retrieves the technician ID assigned to the job card.
+Description: Retrieves the technician ID associated with the job card.
-Parameter: None
+Returns:
-Return type: const std::string&
+    - const std::string& representing the technician ID.
 */
 const std::string& JobCard::getTechnicianId() const
 {
@@ -128,9 +132,9 @@ const std::string& JobCard::getTechnicianId() const
 
 /*
 Function: getTechnician
-Description: Retrieves the technician object assigned to the job card.
+Description: Retrieves the pointer to the assigned technician.
-Parameter: None
+Returns:
-Return type: User*
+    - User* representing the technician.
 */
 User* JobCard::getTechnician() const
 {
@@ -139,9 +143,9 @@ User* JobCard::getTechnician() const
 
 /*
 Function: getAssignedDate
-Description: Retrieves the date when the job was assigned.
+Description: Retrieves the timestamp of when the job was assigned.
-Parameter: None
+Returns:
-Return type: const util::Timestamp&
+    - const util::Timestamp& representing the assigned date.
 */
 const util::Timestamp& JobCard::getAssignedDate() const
 {
@@ -150,20 +154,20 @@ const util::Timestamp& JobCard::getAssignedDate() const
 
 /*
 Function: getStatus
-Description: Retrieves the current status of the job card.
+Description: Retrieves the current status of the job.
-Parameter: None
+Returns:
-Return type: util::ServiceJobStatus
+    - ServiceJobStatus representing the job status.
 */
-util::ServiceJobStatus JobCard::getStatus() const
+ServiceJobStatus JobCard::getStatus() const
 {
     return m_status;
 }
 
 /*
 Function: getCompletionDate
-Description: Retrieves the completion date of the job card.
+Description: Retrieves the timestamp of when the job was completed.
-Parameter: None
+Returns:
-Return type: const util::Timestamp&
+    - const util::Timestamp& representing the completion date.
 */
 const util::Timestamp& JobCard::getCompletionDate() const
 {
@@ -172,9 +176,11 @@ const util::Timestamp& JobCard::getCompletionDate() const
 
 /*
 Function: setId
-Description: Sets the unique identifier of the job card.
+Description: Sets the unique ID of the job card.
-Parameter: const std::string& id - new job card ID
+Parameters:
-Return type: void
+    - id: New job card ID string.
+Returns:
+    - void
 */
 void JobCard::setId(const std::string& id)
 {
@@ -183,9 +189,11 @@ void JobCard::setId(const std::string& id)
 
 /*
 Function: setBookingId
-Description: Sets the booking ID for the job card.
+Description: Sets the booking ID associated with the job card.
-Parameter: const std::string& bookingId - new booking ID
+Parameters:
-Return type: void
+    - bookingId: New booking ID string.
+Returns:
+    - void
 */
 void JobCard::setBookingId(const std::string& bookingId)
 {
@@ -194,9 +202,11 @@ void JobCard::setBookingId(const std::string& bookingId)
 
 /*
 Function: setBooking
-Description: Sets the booking object for the job card.
+Description: Sets the associated ServiceBooking pointer.
-Parameter: ServiceBooking* booking - pointer to the booking object
+Parameters:
-Return type: void
+    - booking: Pointer to the ServiceBooking object.
+Returns:
+    - void
 */
 void JobCard::setBooking(ServiceBooking* booking)
 {
@@ -205,9 +215,11 @@ void JobCard::setBooking(ServiceBooking* booking)
 
 /*
 Function: setService
-Description: Sets the service object for the job card.
+Description: Sets the associated Service pointer.
-Parameter: Service* service - pointer to the service object
+Parameters:
-Return type: void
+    - service: Pointer to the Service object.
+Returns:
+    - void
 */
 void JobCard::setService(Service* service)
 {
@@ -216,9 +228,11 @@ void JobCard::setService(Service* service)
 
 /*
 Function: setServiceId
-Description: Sets the service ID for the job card.
+Description: Sets the service ID associated with the job card.
-Parameter: const std::string& serviceId - new service ID
+Parameters:
-Return type: void
+    - serviceId: New service ID string.
+Returns:
+    - void
 */
 void JobCard::setServiceId(const std::string& serviceId)
 {
@@ -227,9 +241,11 @@ void JobCard::setServiceId(const std::string& serviceId)
 
 /*
 Function: setTechnicianId
-Description: Sets the technician ID for the job card.
+Description: Sets the technician ID associated with the job card.
-Parameter: const std::string& technicianId - new technician ID
+Parameters:
-Return type: void
+    - technicianId: New technician ID string.
+Returns:
+    - void
 */
 void JobCard::setTechnicianId(const std::string& technicianId)
 {
@@ -238,9 +254,11 @@ void JobCard::setTechnicianId(const std::string& technicianId)
 
 /*
 Function: setTechnician
-Description: Sets the technician object for the job card.
+Description: Sets the pointer to the assigned technician.
-Parameter: User* technician - pointer to the technician object
+Parameters:
-Return type: void
+    - technician: Pointer to the User object.
+Returns:
+    - void
 */
 void JobCard::setTechnician(User* technician)
 {
@@ -249,9 +267,11 @@ void JobCard::setTechnician(User* technician)
 
 /*
 Function: setAssignedDate
-Description: Sets the assigned date for the job card.
+Description: Sets the timestamp of when the job was assigned.
-Parameter: const util::Timestamp& assignedDate - new assigned date
+Parameters:
-Return type: void
+    - assignedDate: New timestamp for the assigned date.
+Returns:
+    - void
 */
 void JobCard::setAssignedDate(const util::Timestamp& assignedDate)
 {
@@ -260,20 +280,24 @@ void JobCard::setAssignedDate(const util::Timestamp& assignedDate)
 
 /*
 Function: setStatus
-Description: Sets the status of the job card.
+Description: Sets the current status of the job.
-Parameter: util::ServiceJobStatus status - new job status
+Parameters:
-Return type: void
+    - status: New job status value.
+Returns:
+    - void
 */
-void JobCard::setStatus(util::ServiceJobStatus status)
+void JobCard::setStatus(ServiceJobStatus status)
 {
     m_status = status;
 }
 
 /*
 Function: setCompletionDate
-Description: Sets the completion date for the job card.
+Description: Sets the timestamp of when the job was completed.
-Parameter: const util::Timestamp& completionDate - new completion date
+Parameters:
-Return type: void
+    - completionDate: New timestamp for the completion date.
+Returns:
+    - void
 */
 void JobCard::setCompletionDate(const util::Timestamp& completionDate)
 {

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/JobCard.h

@@ -1,20 +1,21 @@
 /*
 File: JobCard.h
-Description: Header file declaring the JobCard class, which represents
+Description: Declares the JobCard class which represents a technician’s job assignment in the Vehicle Service Management System.
-             a service job card containing booking, service, technician,
+             Each job card includes booking details, associated service, technician information, assigned and completion dates, and job status.
-             and status details.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
+
 #pragma once
 #include <string>
 #include "Timestamp.h"
-#include "Enums.h"
 
 class ServiceBooking;
 class Service;
 class User;
 
+enum class ServiceJobStatus : int;
+
 class JobCard
 {
 private:
@@ -27,8 +28,9 @@ private:
     std::string m_technicianId;
     User* m_technician;
     util::Timestamp m_assignedDate;
-    util::ServiceJobStatus m_status;
+    ServiceJobStatus m_status;
     util::Timestamp m_completionDate;
+
 public:
     JobCard();
     JobCard(const std::string& bookingId,
@@ -38,7 +40,7 @@ public:
         const std::string& technicianId, 
         User* technician, 
         const util::Timestamp& assignedDate, 
-        util::ServiceJobStatus status,
+        ServiceJobStatus status,
         const util::Timestamp& completionDate
     );
     const std::string& getId() const;
@@ -49,7 +51,7 @@ public:
     const std::string& getTechnicianId() const;
     User* getTechnician() const;
     const util::Timestamp& getAssignedDate() const;
-    util::ServiceJobStatus getStatus() const;
+    ServiceJobStatus getStatus() const;
     const util::Timestamp& getCompletionDate() const;
     void setId(const std::string& id);
     void setBookingId(const std::string& bookingId);
@@ -59,6 +61,6 @@ public:
     void setTechnicianId(const std::string& technicianId);
     void setTechnician(User* technician);
     void setAssignedDate(const util::Timestamp& assignedDate);
-    void setStatus(util::ServiceJobStatus status);
+    void setStatus(ServiceJobStatus status);
     void setCompletionDate(const util::Timestamp& completionDate);
 };

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/Notification.cpp

@@ -1,11 +1,39 @@
+/*
+File: Notification.cpp
+Description: Implements the Notification class which represents system notifications in the Vehicle Service Management System.
+             Provides constructors, accessors, and mutators for notification details such as ID, recipient, title, message, and timestamp.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #include "Notification.h"
 
 int Notification::m_uid = 0;
 
+/*
+Function: Notification
+Description: Default constructor that initializes a new notification with a unique ID and null recipient.
+Parameters:
+    - None
+Returns:
+    - A new Notification object.
+*/
 Notification::Notification()
     : m_id("NOT" + std::to_string(++m_uid)),
     m_recipient(nullptr) {}
 
+/*
+Function: Notification
+Description: Parameterized constructor that initializes a new notification with a unique ID and specified details.
+Parameters:
+    - recipientUserId: ID of the recipient user.
+    - recipient: Pointer to the User object representing the recipient.
+    - title: Title of the notification.
+    - message: Message content of the notification.
+    - createdAt: Timestamp of when the notification was created.
+Returns:
+    - A new Notification object.
+*/
 Notification::Notification(const std::string& recipientUserId, User* recipient, const std::string& title, const std::string& message, const util::Timestamp& createdAt)
     : m_id("NOT" + std::to_string(++m_uid)),
     m_recipientUserId(recipientUserId),
@@ -14,61 +42,145 @@ Notification::Notification(const std::string& recipientUserId, User* recipient,
     m_message(message),
     m_createdAt(createdAt) {}
 
+/*
+Function: getId
+Description: Retrieves the unique ID of the notification.
+Returns:
+    - const std::string& representing the notification ID.
+*/
 const std::string& Notification::getId() const 
 {
     return m_id;
 }
 
+/*
+Function: getRecipientUserId
+Description: Retrieves the recipient user ID associated with the notification.
+Returns:
+    - const std::string& representing the recipient user ID.
+*/
 const std::string& Notification::getRecipientUserId() const
 {
     return m_recipientUserId;
 }
 
+/*
+Function: getRecipient
+Description: Retrieves the pointer to the recipient user.
+Returns:
+    - User* representing the recipient.
+*/
 User* Notification::getRecipient() const
 {
     return m_recipient;
 }
 
+/*
+Function: getTitle
+Description: Retrieves the title of the notification.
+Returns:
+    - const std::string& representing the notification title.
+*/
 const std::string& Notification::getTitle() const
 {
     return m_title;
 }
 
+/*
+Function: getMessage
+Description: Retrieves the message content of the notification.
+Returns:
+    - const std::string& representing the notification message.
+*/
 const std::string& Notification::getMessage() const
 {
     return m_message;
 }
 
+/*
+Function: getCreatedAt
+Description: Retrieves the timestamp of when the notification was created.
+Returns:
+    - const util::Timestamp& representing the creation timestamp.
+*/
 const util::Timestamp& Notification::getCreatedAt() const
 {
     return m_createdAt;
 }
 
+/*
+Function: setId
+Description: Sets the unique ID of the notification.
+Parameters:
+    - id: New notification ID string.
+Returns:
+    - void
+*/
 void Notification::setId(const std::string& id)
 {
     m_id = id;
 }
 
+/*
+Function: setRecipientUserId
+Description: Sets the recipient user ID for the notification.
+Parameters:
+    - recipientUserId: New recipient user ID string.
+Returns:
+    - void
+*/
 void Notification::setRecipientUserId(const std::string& recipientUserId)
 {
     m_recipientUserId = recipientUserId;
 }
 
+/*
+Function: setRecipient
+Description: Sets the recipient user pointer for the notification.
+Parameters:
+    - recipient: Pointer to the User object.
+Returns:
+    - void
+*/
 void Notification::setRecipient(User* recipient)
 {
     m_recipient = recipient;
 }
 
+/*
+Function: setTitle
+Description: Sets the title of the notification.
+Parameters:
+    - title: New notification title string.
+Returns:
+    - void
+*/
 void Notification::setTitle(const std::string& title)
 {
     m_title = title;
 }
 
+/*
+Function: setMessage
+Description: Sets the message content of the notification.
+Parameters:
+    - message: New notification message string.
+Returns:
+    - void
+*/
 void Notification::setMessage(const std::string& message)
 {
     m_message = message;
 }
 
+/*
+Function: setCreatedAt
+Description: Sets the timestamp of when the notification was created.
+Parameters:
+    - createdAt: New timestamp value.
+Returns:
+    - void
+*/
 void Notification::setCreatedAt(const util::Timestamp& createdAt)
 {
     m_createdAt = createdAt;

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/Notification.h

@@ -1,3 +1,11 @@
+/*
+File: Notification.h
+Description: Declares the Notification class which represents system messages sent to users in the Vehicle Service Management System.
+             Each notification includes a unique ID, recipient details, title, message content, and timestamp of creation.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #pragma once
 #include <string>
 #include "Timestamp.h"

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/Service.cpp

@@ -1,12 +1,40 @@
+/*
+File: Service.cpp
+Description: Implements the Service class which represents a vehicle service in the Vehicle Service Management System.
+             Provides constructors, accessors, and mutators for service details such as ID, name, required inventory items,
+             labor cost, and state.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #include "Service.h"
 
 int Service::m_uid = 0;
 
+/*
+Function: Service
+Description: Default constructor that initializes a new service with a unique ID,
+             active state, and zero labor cost.
+Parameters:
+    - None
+Returns:
+    - A new Service object.
+*/
 Service::Service()
     : m_id("SRV" + std::to_string(++m_uid)),
     m_status(util::State::ACTIVE),
     m_laborCost(0.0) {}
 
+/*
+Function: Service
+Description: Parameterized constructor that initializes a new service with a unique ID and specified details.
+Parameters:
+    - name: Name of the service.
+    - requiredInventoryItems: Map of inventory items required for the service.
+    - laborCost: Labor cost associated with the service.
+Returns:
+    - A new Service object.
+*/
 Service::Service(const std::string& name, const util::Map<std::string, InventoryItem*>& requiredInventoryItems, double laborCost)
     : m_id("SRV" + std::to_string(++m_uid)),
     m_name(name),
@@ -14,51 +42,121 @@ Service::Service(const std::string& name, const util::Map<std::string, Inventory
     m_status(util::State::ACTIVE),
     m_laborCost(laborCost) {}
 
+/*
+Function: getId
+Description: Retrieves the unique ID of the service.
+Returns:
+    - const std::string& representing the service ID.
+*/
 const std::string& Service::getId() const
 {
     return m_id;
 }
 
+/*
+Function: getName
+Description: Retrieves the name of the service.
+Returns:
+    - const std::string& representing the service name.
+*/
 const std::string& Service::getName() const
 {
     return m_name;
 }
 
+/*
+Function: getRequiredInventoryItems
+Description: Retrieves the map of inventory items required for the service.
+Returns:
+    - const util::Map<std::string, InventoryItem*>& representing the required inventory items.
+*/
 const util::Map<std::string, InventoryItem*>& Service::getRequiredInventoryItems() const
 {
     return m_requiredInventoryItems;
 }
 
+/*
+Function: getLaborCost
+Description: Retrieves the labor cost associated with the service.
+Returns:
+    - double representing the labor cost.
+*/
 double Service::getLaborCost() const
 {
     return m_laborCost;
 }
 
+/*
+Function: getState
+Description: Retrieves the current state (ACTIVE/INACTIVE) of the service.
+Returns:
+    - util::State representing the service state.
+*/
 util::State Service::getState() const
 {
     return m_status;
 }
 
+/*
+Function: setId
+Description: Sets the unique ID of the service.
+Parameters:
+    - id: New service ID string.
+Returns:
+    - void
+*/
 void Service::setId(const std::string& id)
 {
     m_id = id;
 }
 
+/*
+Function: setName
+Description: Sets the name of the service.
+Parameters:
+    - name: New service name string.
+Returns:
+    - void
+*/
 void Service::setName(const std::string& name)
 {
     m_name = name;
 }
 
+/*
+Function: setRequiredInventoryItems
+Description: Sets the inventory items required for the service.
+Parameters:
+    - requiredInventoryItems: Map of inventory items.
+Returns:
+    - void
+*/
 void Service::setRequiredInventoryItems(const util::Map<std::string, InventoryItem*>& requiredInventoryItems)
 {
     m_requiredInventoryItems = requiredInventoryItems;
 }
 
+/*
+Function: setLaborCost
+Description: Sets the labor cost for the service.
+Parameters:
+    - laborCost: New labor cost value.
+Returns:
+    - void
+*/
 void Service::setLaborCost(double laborCost)
 {
     m_laborCost = laborCost;
 }
 
+/*
+Function: setState
+Description: Sets the state (ACTIVE/INACTIVE) of the service.
+Parameters:
+    - status: New state value.
+Returns:
+    - void
+*/
 void Service::setState(util::State status)
 {
     m_status = status;

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/Service.h

@@ -1,3 +1,12 @@
+/*
+File: Service.h
+Description: Declares the Service class which represents a vehicle service in the Vehicle Service Management System.
+             Each service includes a unique ID, name, required inventory items, labor cost, and status.
+Author: Trenser
+Date: 19-May-2026
+*/
+
+
 #pragma once
 #include <string>
 #include "Map.h"

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/ServiceBooking.cpp

@@ -1,21 +1,24 @@
 /*
 File: ServiceBooking.cpp
-Description: Implementation file containing the method definitions of the
+Description: Implements the ServiceBooking class which represents a customer’s service booking in the Vehicle Service Management System.
-             ServiceBooking class, including constructors, getters, and setters
+             Provides constructors, accessors, and mutators for booking details such as ID, status, services, customer,
-             for booking attributes.
+             vehicle information, assigned technician, and discount percentage.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
+
 #include "ServiceBooking.h"
 
 int ServiceBooking::m_uid = 0;
 
 /*
 Function: ServiceBooking
-Description: Default constructor that initializes a new service booking
+Description: Default constructor that initializes a new service booking with a unique ID,
-             with a unique ID, no customer, and zero discount.
+             null customer, and zero discount percentage.
-Parameter: None
+Parameters:
-Return type: Constructor
+    - None
+Returns:
+    - A new ServiceBooking object.
 */
 ServiceBooking::ServiceBooking()
     : m_id("SRV" + std::to_string(++m_uid)),
@@ -24,20 +27,21 @@ ServiceBooking::ServiceBooking()
 
 /*
 Function: ServiceBooking
-Description: Parameterized constructor that initializes a service booking
+Description: Parameterized constructor that initializes a new service booking with a unique ID and specified details.
-             with customer, vehicle, technician, and discount details.
+Parameters:
-Parameter: const std::string& id - booking ID
+    - id: Booking ID string.
-           util::ServiceJobStatus status - current booking status
+    - status: Current status of the booking (e.g., PENDING, COMPLETED).
-           const util::Map<std::string, Service*>& services - map of services
+    - services: Map of services included in the booking.
-           const std::string& customerId - ID of the customer
+    - customerId: ID of the customer.
-           User* customer - pointer to the customer object
+    - customer: Pointer to the User object representing the customer.
-           const std::string& vehicleNumber - vehicle registration number
+    - vehicleNumber: Vehicle registration number.
-           const std::string& vehicleBrand - brand of the vehicle
+    - vehicleBrand: Brand of the vehicle.
-           const std::string& vehicleModel - model of the vehicle
+    - vehicleModel: Model of the vehicle.
-           const std::string& assignedTechnicianId - ID of the assigned technician
+    - assignedTechnicianId: ID of the assigned technician.
-           User* assignedTechnician - pointer to the technician object
+    - assignedTechnician: Name of the assigned technician.
-           double discountPercentage - discount applied to the booking
+    - discountPercentage: Discount applied to the booking.
-Return type: Constructor
+Returns:
+    - A new ServiceBooking object.
 */
 ServiceBooking::ServiceBooking(
     const std::string& id,
@@ -50,7 +54,7 @@ ServiceBooking::ServiceBooking(
     const std::string& vehicleBrand,
     const std::string& vehicleModel,
     const std::string& assignedTechnicianId,
-    User* assignedTechnician,
+    const std::string& assignedTechnician,
     double discountPercentage
 )
     : m_id("SRV" + std::to_string(++m_uid)),
@@ -69,9 +73,9 @@ ServiceBooking::ServiceBooking(
 
 /*
 Function: getId
-Description: Retrieves the unique identifier of the service booking.
+Description: Retrieves the unique ID of the service booking.
-Parameter: None
+Returns:
-Return type: const std::string&
+    - const std::string& representing the booking ID.
 */
 const std::string& ServiceBooking::getId() const
 {
@@ -81,8 +85,8 @@ const std::string& ServiceBooking::getId() const
 /*
 Function: getStatus
 Description: Retrieves the current status of the service booking.
-Parameter: None
+Returns:
-Return type: util::ServiceJobStatus
+    - util::ServiceJobStatus representing the booking status.
 */
 util::ServiceJobStatus ServiceBooking::getStatus() const
 {
@@ -91,9 +95,9 @@ util::ServiceJobStatus ServiceBooking::getStatus() const
 
 /*
 Function: getServices
-Description: Retrieves the services associated with the booking.
+Description: Retrieves the map of services included in the booking.
-Parameter: None
+Returns:
-Return type: const util::Map<std::string, Service*>&
+    - const util::Map<std::string, Service*>& representing the services.
 */
 const util::Map<std::string, Service*>& ServiceBooking::getServices() const
 {
@@ -103,8 +107,8 @@ const util::Map<std::string, Service*>& ServiceBooking::getServices() const
 /*
 Function: getCustomerId
 Description: Retrieves the customer ID associated with the booking.
-Parameter: None
+Returns:
-Return type: const std::string&
+    - const std::string& representing the customer ID.
 */
 const std::string& ServiceBooking::getCustomerId() const
 {
@@ -113,9 +117,9 @@ const std::string& ServiceBooking::getCustomerId() const
 
 /*
 Function: getCustomer
-Description: Retrieves the customer object associated with the booking.
+Description: Retrieves the pointer to the associated customer.
-Parameter: None
+Returns:
-Return type: User*
+    - User* representing the customer.
 */
 User* ServiceBooking::getCustomer() const
 {
@@ -124,9 +128,9 @@ User* ServiceBooking::getCustomer() const
 
 /*
 Function: getVehicleNumber
-Description: Retrieves the vehicle registration number for the booking.
+Description: Retrieves the vehicle registration number.
-Parameter: None
+Returns:
-Return type: const std::string&
+    - const std::string& representing the vehicle number.
 */
 const std::string& ServiceBooking::getVehicleNumber() const
 {
@@ -135,9 +139,9 @@ const std::string& ServiceBooking::getVehicleNumber() const
 
 /*
 Function: getVehicleBrand
-Description: Retrieves the brand of the vehicle for the booking.
+Description: Retrieves the brand of the vehicle.
-Parameter: None
+Returns:
-Return type: const std::string&
+    - const std::string& representing the vehicle brand.
 */
 const std::string& ServiceBooking::getVehicleBrand() const
 {
@@ -146,9 +150,9 @@ const std::string& ServiceBooking::getVehicleBrand() const
 
 /*
 Function: getVehicleModel
-Description: Retrieves the model of the vehicle for the booking.
+Description: Retrieves the model of the vehicle.
-Parameter: None
+Returns:
-Return type: const std::string&
+    - const std::string& representing the vehicle model.
 */
 const std::string& ServiceBooking::getVehicleModel() const
 {
@@ -157,9 +161,9 @@ const std::string& ServiceBooking::getVehicleModel() const
 
 /*
 Function: getAssignedTechnicianId
-Description: Retrieves the ID of the technician assigned to the booking.
+Description: Retrieves the ID of the assigned technician.
-Parameter: None
+Returns:
-Return type: const std::string&
+    - const std::string& representing the technician ID.
 */
 const std::string& ServiceBooking::getAssignedTechnicianId() const
 {
@@ -168,11 +172,11 @@ const std::string& ServiceBooking::getAssignedTechnicianId() const
 
 /*
 Function: getAssignedTechnician
-Description: Retrieves the technician object assigned to the booking.
+Description: Retrieves the name of the assigned technician.
-Parameter: None
+Returns:
-Return type: User*
+    - const std::string& representing the technician name.
 */
-User* ServiceBooking::getAssignedTechnician() const
+const std::string& ServiceBooking::getAssignedTechnician() const
 {
     return m_assignedTechnician;
 }
@@ -180,8 +184,8 @@ User* ServiceBooking::getAssignedTechnician() const
 /*
 Function: getDiscountPercentage
 Description: Retrieves the discount percentage applied to the booking.
-Parameter: None
+Returns:
-Return type: double
+    - double representing the discount percentage.
 */
 double ServiceBooking::getDiscountPercentage() const
 {
@@ -190,9 +194,11 @@ double ServiceBooking::getDiscountPercentage() const
 
 /*
 Function: setId
-Description: Sets the unique identifier of the service booking.
+Description: Sets the unique ID of the service booking.
-Parameter: const std::string& id - new booking ID
+Parameters:
-Return type: void
+    - id: New booking ID string.
+Returns:
+    - void
 */
 void ServiceBooking::setId(const std::string& id)
 {
@@ -202,8 +208,10 @@ void ServiceBooking::setId(const std::string& id)
 /*
 Function: setStatus
 Description: Sets the current status of the service booking.
-Parameter: const util::ServiceJobStatus& status - new booking status
+Parameters:
-Return type: void
+    - status: New booking status value.
+Returns:
+    - void
 */
 void ServiceBooking::setStatus(const util::ServiceJobStatus& status)
 {
@@ -212,9 +220,11 @@ void ServiceBooking::setStatus(const util::ServiceJobStatus& status)
 
 /*
 Function: setServices
-Description: Sets the services associated with the booking.
+Description: Sets the services included in the booking.
-Parameter: const util::Map<std::string, Service*>& services - new services map
+Parameters:
-Return type: void
+    - services: Map of services.
+Returns:
+    - void
 */
 void ServiceBooking::setServices(const util::Map<std::string, Service*>& services)
 {
@@ -223,9 +233,11 @@ void ServiceBooking::setServices(const util::Map<std::string, Service*>& service
 
 /*
 Function: setCustomerId
-Description: Sets the customer ID for the booking.
+Description: Sets the customer ID associated with the booking.
-Parameter: const std::string& customerId - new customer ID
+Parameters:
-Return type: void
+    - customerId: New customer ID string.
+Returns:
+    - void
 */
 void ServiceBooking::setCustomerId(const std::string& customerId)
 {
@@ -234,9 +246,11 @@ void ServiceBooking::setCustomerId(const std::string& customerId)
 
 /*
 Function: setCustomer
-Description: Sets the customer object for the booking.
+Description: Sets the pointer to the associated customer.
-Parameter: User* customer - pointer to the customer object
+Parameters:
-Return type: void
+    - customer: Pointer to the User object.
+Returns:
+    - void
 */
 void ServiceBooking::setCustomer(User* customer)
 {
@@ -245,9 +259,11 @@ void ServiceBooking::setCustomer(User* customer)
 
 /*
 Function: setVehicleNumber
-Description: Sets the vehicle registration number for the booking.
+Description: Sets the vehicle registration number.
-Parameter: const std::string& vehicleNumber - new vehicle number
+Parameters:
-Return type: void
+    - vehicleNumber: New vehicle number string.
+Returns:
+    - void
 */
 void ServiceBooking::setVehicleNumber(const std::string& vehicleNumber)
 {
@@ -256,9 +272,11 @@ void ServiceBooking::setVehicleNumber(const std::string& vehicleNumber)
 
 /*
 Function: setVehicleBrand
-Description: Sets the brand of the vehicle for the booking.
+Description: Sets the brand of the vehicle.
-Parameter: const std::string& vehicleBrand - new vehicle brand
+Parameters:
-Return type: void
+    - vehicleBrand: New vehicle brand string.
+Returns:
+    - void
 */
 void ServiceBooking::setVehicleBrand(const std::string& vehicleBrand)
 {
@@ -267,9 +285,11 @@ void ServiceBooking::setVehicleBrand(const std::string& vehicleBrand)
 
 /*
 Function: setVehicleModel
-Description: Sets the model of the vehicle for the booking.
+Description: Sets the model of the vehicle.
-Parameter: const std::string& vehicleModel - new vehicle model
+Parameters:
-Return type: void
+    - vehicleModel: New vehicle model string.
+Returns:
+    - void
 */
 void ServiceBooking::setVehicleModel(const std::string& vehicleModel)
 {
@@ -278,9 +298,11 @@ void ServiceBooking::setVehicleModel(const std::string& vehicleModel)
 
 /*
 Function: setAssignedTechnicianId
-Description: Sets the ID of the technician assigned to the booking.
+Description: Sets the ID of the assigned technician.
-Parameter: const std::string& assignedTechnicianId - new technician ID
+Parameters:
-Return type: void
+    - assignedTechnicianId: New technician ID string.
+Returns:
+    - void
 */
 void ServiceBooking::setAssignedTechnicianId(const std::string& assignedTechnicianId)
 {
@@ -289,20 +311,24 @@ void ServiceBooking::setAssignedTechnicianId(const std::string& assignedTechnici
 
 /*
 Function: setAssignedTechnician
-Description: Sets the technician object assigned to the booking.
+Description: Sets the name of the assigned technician.
-Parameter: User* assignedTechnician - pointer to the technician object
+Parameters:
-Return type: void
+    - assignedTechnician: New technician name string.
+Returns:
+    - void
 */
-void ServiceBooking::setAssignedTechnician(User* assignedTechnician)
+void ServiceBooking::setAssignedTechnician(const std::string& assignedTechnician)
 {
     m_assignedTechnician = assignedTechnician;
 }
 
 /*
 Function: setDiscountPercentage
-Description: Sets the discount percentage for the booking.
+Description: Sets the discount percentage applied to the booking.
-Parameter: double discountPercentage - new discount percentage
+Parameters:
-Return type: void
+    - discountPercentage: New discount percentage value.
+Returns:
+    - void
 */
 void ServiceBooking::setDiscountPercentage(double discountPercentage)
 {

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/ServiceBooking.h

@@ -1,11 +1,11 @@
 /*
 File: ServiceBooking.h
-Description: Header file declaring the ServiceBooking class, which represents
+Description: Declares the ServiceBooking class which represents a customer’s service booking in the Vehicle Service Management System.
-             a booking of services by a customer, including vehicle details,
+             Each booking includes a unique ID, status, associated services, customer details, vehicle information, assigned technician, and discount percentage.
-             assigned technician, and discount information.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
+
 #pragma once
 #include <string>
 #include "Map.h"
@@ -27,7 +27,7 @@ private:
     std::string m_vehicleBrand;
     std::string m_vehicleModel;
     std::string m_assignedTechnicianId;
-    User* m_assignedTechnician;
+    std::string m_assignedTechnician;
     double m_discountPercentage;
 public:
     ServiceBooking();
@@ -42,7 +42,7 @@ public:
         const std::string& vehicleBrand,
         const std::string& vehicleModel,
         const std::string& assignedTechnicianId,
-        User* assignedTechnician,
+        const std::string& assignedTechnician,
         double discountPercentage
     );
     const std::string& getId() const;
@@ -54,7 +54,7 @@ public:
     const std::string& getVehicleBrand() const;
     const std::string& getVehicleModel() const;
     const std::string& getAssignedTechnicianId() const;
-    User* getAssignedTechnician() const;
+    const std::string& getAssignedTechnician() const;
     double getDiscountPercentage() const;
     void setId(const std::string& id);
     void setStatus(const util::ServiceJobStatus& status);
@@ -65,6 +65,6 @@ public:
     void setVehicleBrand(const std::string& vehicleBrand);
     void setVehicleModel(const std::string& vehicleModel);
     void setAssignedTechnicianId(const std::string& assignedTechnicianId);
-    void setAssignedTechnician(User* assignedTechnician);
+    void setAssignedTechnician(const std::string& assignedTechnician);
     void setDiscountPercentage(double discountPercentage);
 };

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/User.cpp

@@ -1,14 +1,45 @@
+/*
+File: User.cpp
+Description: Implements the User class which represents system users in the Vehicle Service Management System.
+             Provides constructors, destructor, accessors, and mutators for user details such as ID, username,
+             password, name, phone, email, role, state, and notifications.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #include "User.h"
 #include "Notification.h"
 #include "Enums.h"
 
 int User::m_uid = 0;
 
+/*
+Function: User
+Description: Default constructor that initializes a new user with a unique ID,
+             default role as CUSTOMER, and active state.
+Parameters:
+    - None
+Returns:
+    - A new User object.
+*/
 User::User()
     : m_id("USR" + std::to_string(++m_uid)),
     m_type(util::UserType::CUSTOMER),
     m_status(util::State::ACTIVE) {}
 
+/*
+Function: User
+Description: Parameterized constructor that initializes a new user with a unique ID and specified details.
+Parameters:
+    - userName: Username for login.
+    - password: Password for authentication.
+    - name: Full name of the user.
+    - phone: Phone number of the user.
+    - email: Email address of the user.
+    - role: Role of the user (CUSTOMER, ADMIN, TECHNICIAN, etc.).
+Returns:
+    - A new User object.
+*/
 User::User(const std::string& userName, const std::string& password, const std::string& name, const std::string& phone, const std::string& email, util::UserType role)
     : m_id("USR" + std::to_string(++m_uid)),
     m_userName(userName),
@@ -19,6 +50,14 @@ User::User(const std::string& userName, const std::string& password, const std::
     m_type(role),
     m_status(util::State::ACTIVE) {}
 
+/*
+Function: ~User
+Description: Destructor that cleans up dynamically allocated notifications associated with the user.
+Parameters:
+    - None
+Returns:
+    - void
+*/
 User::~User()
 {
     for (int index = 0; index < m_notifications.getSize(); index++)
@@ -27,96 +66,221 @@ User::~User()
     }
 }
 
+/*
+Function: getId
+Description: Retrieves the unique ID of the user.
+Returns:
+    - const std::string& representing the user ID.
+*/
 const std::string& User::getId() const
 {
     return m_id;
 }
 
+/*
+Function: getUserName
+Description: Retrieves the username of the user.
+Returns:
+    - const std::string& representing the username.
+*/
 const std::string& User::getUserName() const
 {
     return m_userName;
 }
 
+/*
+Function: getPassword
+Description: Retrieves the password of the user.
+Returns:
+    - const std::string& representing the password.
+*/
 const std::string& User::getPassword() const
 {
     return m_password;
 }
 
+/*
+Function: getName
+Description: Retrieves the full name of the user.
+Returns:
+    - const std::string& representing the name.
+*/
 const std::string& User::getName() const
 {
     return m_name;
 }
 
+/*
+Function: getPhone
+Description: Retrieves the phone number of the user.
+Returns:
+    - const std::string& representing the phone number.
+*/
 const std::string& User::getPhone() const
 {
     return m_phone;
 }
 
+/*
+Function: getEmail
+Description: Retrieves the email address of the user.
+Returns:
+    - const std::string& representing the email.
+*/
 const std::string& User::getEmail() const
 {
     return m_email;
 }
 
+/*
+Function: getNotifications
+Description: Retrieves the map of notifications associated with the user.
+Returns:
+    - util::Map<std::string, Notification*>& representing the notifications.
+*/
 util::Map<std::string, Notification*>& User::getNotifications()
 {
     return m_notifications;
 }
 
+/*
+Function: getUserType
+Description: Retrieves the role of the user.
+Returns:
+    - util::UserType representing the user role.
+*/
 util::UserType User::getUserType() const
 {
     return m_type;
 }
 
+/*
+Function: getState
+Description: Retrieves the current state (ACTIVE/INACTIVE) of the user.
+Returns:
+    - util::State representing the user state.
+*/
 util::State User::getState() const
 {
     return m_status;
 }
 
+/*
+Function: setId
+Description: Sets the unique ID of the user.
+Parameters:
+    - id: New user ID string.
+Returns:
+    - void
+*/
 void User::setId(const std::string& id)
 {
     m_id = id;
 }
 
+/*
+Function: setUserName
+Description: Sets the username of the user.
+Parameters:
+    - userName: New username string.
+Returns:
+    - void
+*/
 void User::setUserName(const std::string& userName)
 {
     m_userName = userName;
 }
 
+/*
+Function: setPassword
+Description: Sets the password of the user.
+Parameters:
+    - password: New password string.
+Returns:
+    - void
+*/
 void User::setPassword(const std::string& password)
 {
     m_password = password;
 }
 
+/*
+Function: setName
+Description: Sets the full name of the user.
+Parameters:
+    - name: New name string.
+Returns:
+    - void
+*/
 void User::setName(const std::string& name)
 {
     m_name = name;
 }
 
+/*
+Function: setPhone
+Description: Sets the phone number of the user.
+Parameters:
+    - phone: New phone number string.
+Returns:
+    - void
+*/
 void User::setPhone(const std::string& phone)
 {
     m_phone = phone;
 }
 
+/*
+Function: setEmail
+Description: Sets the email address of the user.
+Parameters:
+    - email: New email string.
+Returns:
+    - void
+*/
 void User::setEmail(const std::string& email)
 {
     m_email = email;
 }
 
+/*
+Function: addNotification
+Description: Adds a new notification to the user’s notification map.
+Parameters:
+    - notification: Pointer to the Notification object.
+Returns:
+    - void
+*/
 void User::addNotification(Notification* notification)
 {
+    if (notification)
+    {
         m_notifications.insert(notification->getId(), notification);
+    }
 }
 
+/*
+Function: setRole
+Description: Sets the role of the user.
+Parameters:
+    - role: New user role value.
+Returns:
+    - void
+*/
 void User::setRole(util::UserType role)
 {
     m_type = role;
 }
 
+/*
+Function: setState
+Description: Sets the state (ACTIVE/INACTIVE) of the user.
+Parameters:
+    - status: New state value.
+Returns:
+    - void
+*/
 void User::setState(util::State status)
 {
     m_status = status;
 }
-
-void User::update(Notification* notification)
-{
-}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/User.h

@@ -1,3 +1,12 @@
+/*
+File: User.h
+Description: Declares the User class which represents system users in the Vehicle Service Management System.
+             Each user has a unique ID, credentials, personal details, notifications, role type, and status.
+             The User class also implements the Observer interface to handle notifications.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #pragma once
 #include <string>
 #include "Map.h"
@@ -38,8 +47,7 @@ public:
     void setName(const std::string& name);
     void setPhone(const std::string& phone);
     void setEmail(const std::string& email);
-    void addNotification(Notification* notification);
+    void addNotification(Notification* notification) override;
     void setRole(util::UserType role);
     void setState(util::State status);
-    void update(Notification* notification) override;
 };

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/AuthenticationManagementService.cpp

@@ -1,40 +1,3 @@
-/*
-File: AuthenticationManagementService.cpp
-Description: Implementation file containing the method definitions of the
-			 AuthenticationManagementService class, including logout and
-			 password change logic.
-Author: Trenser
-Date:19-May-2026
-*/
 #include "AuthenticationManagementService.h"
-#include "User.h"
 
 User* AuthenticationManagementService::m_authenticatedUser = nullptr;
-
-/*
-Function: logout
-Description: Logs out the currently authenticated user by clearing the
-			 static authenticated user pointer.
-Parameter: None
-Return type: void
-*/
-void AuthenticationManagementService::logout()
-{
-	m_authenticatedUser = nullptr;
-}
-
-/*
-Function: changePassword
-Description: Changes the password of the currently authenticated user.
-			 Throws an exception if no user is logged in.
-Parameter: const std::string& newPassword - new password to set
-Return type: void
-*/
-void AuthenticationManagementService::changePassword(const std::string& newPassword)
-{
-	if (m_authenticatedUser == nullptr)
-	{
-		throw std::runtime_error("There is no user currently logged in!");
-	}
-	m_authenticatedUser->setPassword(newPassword);
-}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/AuthenticationManagementService.h

@@ -1,11 +1,11 @@
 /*
 File: AuthenticationManagementService.h
-Description: Header file declaring the AuthenticationManagementService class, which manages
+Description: Declares the AuthenticationManagementService class which manages user authentication in the Vehicle Service Management System.
-             user authentication, login, logout, password changes, and retrieval of the
+             Provides functionality for login, logout, password change, and retrieving the currently authenticated user.
-             authenticated user.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
+
 #pragma once
 #include <string>
 #include "DataStore.h"

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/InventoryManagementService.cpp

@@ -1 +1,105 @@
+#include <stdexcept>
 #include "InventoryManagementService.h"
+#include "Vector.h"
+#include "Enums.h"
+#include "InventoryItem.h"
+#include "Config.h"
+#include "User.h"
+#include "Factory.h"
+#include "Timestamp.h"
+
+util::Map<std::string, User*> InventoryManagementService::m_observers{};
+
+void InventoryManagementService::attach(User* user)
+{
+	if (user)
+	{
+		const std::string& userID = user->getId();
+		if (m_observers.find(userID) == -1)
+		{
+			m_observers[userID] = user;
+		}
+	}
+}
+
+void InventoryManagementService::detach(User* user)
+{
+	if (user)
+	{
+		const std::string& userID = user->getId();
+		if (m_observers.find(userID) != -1)
+		{
+			m_observers.remove(userID);
+		}
+	}
+}
+
+void InventoryManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
+{
+	if (user)
+	{
+		if (m_observers.find(user->getId()) != -1)
+		{
+			Notification* notification =
+				Factory::getObject<Notification>(
+					user->getId(),
+					user,
+					"InventoryManagementService: " + title,
+					message,
+					util::Timestamp()
+				);
+			if (notification)
+			{
+				user->addNotification(notification);
+			}
+			else
+			{
+				throw std::runtime_error("Failed to create notification");
+			}
+		}
+	}
+}
+
+static void sendLowStockAlertsToAdmins(InventoryManagementService& inventoryManagementService, const InventoryItem* inventoryItem, const util::Vector<User*>& adminUsers)
+{
+	int adminUsersSize = adminUsers.getSize();
+	for (int index = 0; index < adminUsersSize; index++)
+	{
+		inventoryManagementService.sendNotification(
+			adminUsers[index],
+			"Low Stock Alert",
+			"The inventory item with ID " + inventoryItem->getId() +
+			" has very low quantity in the inventory"
+			);
+	}
+}
+
+void InventoryManagementService::sendLowStockAlerts()
+{
+	auto& inventoryItems = m_dataStore.getInventoryItems();
+	int inventoryItemsSize = inventoryItems.getSize();
+	auto& usersMap = m_dataStore.getUsers();
+	int usersMapSize = usersMap.getSize();
+	util::Vector<User*> adminUsers;
+	for (int index = 0; index < usersMapSize; index++)
+	{
+		User* user = usersMap.getValueAt(index);
+		if (user->getUserType() == util::UserType::ADMIN)
+		{
+			adminUsers.push_back(user);
+		}
+	}
+	int adminUsersSize = adminUsers.getSize();
+	if (adminUsersSize < 1)
+	{
+		throw std::runtime_error("The system has no admins present!");
+	}
+	for (int index = 0; index <= inventoryItemsSize; index++)
+	{
+		InventoryItem* inventoryItem = inventoryItems.getValueAt(index);
+		if (inventoryItem && inventoryItem->getQuantity() < config::threshold::INVENTORY_LOW_STOCK_THRESHOLD)
+		{
+			sendLowStockAlertsToAdmins(*this, inventoryItem, adminUsers);
+		}
+	}
+}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/InventoryManagementService.h

@@ -1,3 +1,11 @@
+/*
+File: InventoryManagementService.h
+Description: Declares the InventoryManagementService class which manages inventory operations in the Vehicle Service Management System.
+             Provides functionality to retrieve, add, and remove inventory items, send low stock alerts, and handle notifications using the Observer pattern.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #pragma once
 #include <string>
 #include "Map.h"

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/NotificationManagementService.h

@@ -1,6 +1,15 @@
+/*
+File: NotificationManagementService.h
+Description: Declares the NotificationManagementService abstract class which defines the contract for managing notifications in the Vehicle Service Management System.
+			 Implements the Subject interface and provides pure virtual methods for sending notifications and managing user subscriptions (attach/detach).
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #pragma once
 #include <string>
 #include "Subject.h"
+#include "Notification.h"
 #include "User.h"
 
 class NotificationManagementService : public Subject

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/PaymentManagementService.cpp

@@ -1 +1,136 @@
+/*
+File: PaymentManagementService.cpp
+Description: Implements the PaymentManagementService class which manages payment-related operations
+			 in the Vehicle Service Management System. Provides functionality for attaching/detaching observers,
+			 sending notifications, and issuing payment reminders based on invoice status and thresholds.
+Author: Trenser
+Date: 20-May-2026
+*/
+
+#include <stdexcept>
 #include "PaymentManagementService.h"
+#include "Invoice.h"
+#include "ServiceBooking.h"
+#include "Enums.h"
+#include "Timestamp.h"
+#include "Config.h"
+#include "User.h"
+#include "Factory.h"
+
+util::Map<std::string, User*> PaymentManagementService::m_observers{};
+
+/*
+Function: attach
+Description: Attaches a user as an observer to the PaymentManagementService for receiving notifications.
+Parameters:
+	- user: Pointer to the User object to be attached.
+Returns:
+	- void
+*/
+void PaymentManagementService::attach(User* user)
+{
+	if (user)
+	{
+		const std::string& userID = user->getId();
+		if (m_observers.find(userID) == -1)
+		{
+			m_observers[userID] = user;
+		}
+	}
+}
+
+/*
+Function: detach
+Description: Detaches a user from the observer list of the PaymentManagementService.
+Parameters:
+	- user: Pointer to the User object to be detached.
+Returns:
+	- void
+*/
+void PaymentManagementService::detach(User* user)
+{
+	if (user)
+	{
+		const std::string& userID = user->getId();
+		if (m_observers.find(userID) != -1)
+		{
+			m_observers.remove(userID);
+		}
+	}
+}
+
+/*
+Function: sendNotification
+Description: Sends a notification to a user if they are registered as an observer.
+Parameters:
+	- user: Pointer to the User object to receive the notification.
+	- title: Title of the notification.
+	- message: Message content of the notification.
+Returns:
+	- void
+Throws:
+	- std::runtime_error if notification creation fails.
+*/
+void PaymentManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
+{
+	if (user)
+	{
+		if (m_observers.find(user->getId()) != -1)
+		{
+			Notification* notification =
+				Factory::getObject<Notification>(
+					user->getId(),
+					user,
+					"PaymentManagementService: " + title,
+					message,
+					util::Timestamp()
+				);
+			if (notification)
+			{
+				user->addNotification(notification);
+			}
+			else
+			{
+				throw std::runtime_error("Failed to create notification");
+			}
+		}
+	}
+}
+
+/*
+Function: sendPaymentReminders
+Description: Iterates through all invoices in the datastore and sends payment reminders to customers
+			 whose invoices are pending beyond the configured threshold duration.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void PaymentManagementService::sendPaymentReminders()
+{
+	auto& invoicesMap = m_dataStore.getInvoices();
+	int invoicesMapSize = invoicesMap.getSize();
+	for (int index = 0; index < invoicesMapSize; index++)
+	{
+		const Invoice* invoice = invoicesMap.getValueAt(index);
+		if (invoice && invoice->getStatus() == util::PaymentStatus::PENDING)
+		{
+			util::Timestamp invoiceCreationTimestamp = invoice->getInvoiceDate();
+			util::Timestamp currentTimestamp;
+			if (util::Timestamp::getDurationInHours(invoiceCreationTimestamp, currentTimestamp) >= config::threshold::PAYMENT_REMINDER_THRESHOLD_HOURS)
+			{
+				const ServiceBooking* serviceBooking = invoice->getBooking();
+				if (serviceBooking)
+				{
+					User* customer = serviceBooking->getCustomer();
+					if (customer)
+					{
+						sendNotification(customer,
+							"Payment Reminder",
+							"Your payment for Invoice ID " + invoice->getId() + " is still pending.Please complete the payment." + invoice->getId());
+					}
+				}
+			}
+		}
+	}
+}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/PaymentManagementService.h

@@ -1,3 +1,12 @@
+/*
+File: PaymentManagementService.h
+Description: Declares the PaymentManagementService class which manages payment operations in the Vehicle Service Management System.
+             Provides functionality to generate invoices, retrieve customer invoices, complete payments, send payment reminders,
+             and handle notifications using the Observer pattern.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #pragma once
 #include <string>
 #include "Map.h"

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/ServiceManagementService.cpp

@@ -1,231 +1,94 @@
 /*
 File: ServiceManagementService.cpp
-Description: Implementation file containing the method definitions of the
+Description: Implements the ServiceManagementService class which manages service-related operations
-             ServiceManagementService class, including service booking cancellation,
+			 in the Vehicle Service Management System. Provides functionality for attaching/detaching observers
-             job card management, combo package creation, and removal logic.
+			 and sending notifications to users regarding service events.
 Author: Trenser
-Date:19-May-2026
+Date: 20-May-2026
 */
+
+#include <stdexcept>
 #include "ServiceManagementService.h"
-#include "DataStore.h"
+#include "User.h"
-#include "ServiceBooking.h"
-#include "JobCard.h"
-#include "Service.h"
-#include "InventoryItem.h"
 #include "Factory.h"
-#include "ComboPackage.h"
+#include "Timestamp.h"
+
+util::Map<std::string, User*> ServiceManagementService::m_observers{};
 
 /*
-Function: cancelCustomerServiceBookings
+Function: attach
-Description: Cancels all service bookings associated with a given customer or technician.
+Description: Attaches a user as an observer to the ServiceManagementService for receiving notifications.
-             Updates booking status, resets customer/technician assignments, sends notifications,
+Parameters:
-             and restocks inventory items.
+	- user: Pointer to the User object to be attached.
-Parameter: const std::string& userID - ID of the customer or technician
+Returns:
-Return type: void
+	- void
 */
-void ServiceManagementService::cancelCustomerServiceBookings(const std::string& userID)
+void ServiceManagementService::attach(User* user)
 {
-    const int INCREMENT_VALUE = 1;
+	if (user)
-    auto& users = m_dataStore.getUsers();
-    int userIndex = users.find(userID);
-    if (userIndex == -1)
 	{
-        throw std::runtime_error("User not found: " + userID);
+		const std::string& userID = user->getId();
-    }
+		if (m_observers.find(userID) == -1)
-    User* user = users.getValueAt(userIndex);
-    if (user == nullptr)
 		{
-        throw std::runtime_error("User not found: " + userID);
+			m_observers[userID] = user;
-    }
-    util::UserType type = user->getUserType();
-    auto& bookings = DataStore::getInstance().getServiceBookings();
-    for (int bookingIterator = 0; bookingIterator < bookings.getSize(); bookingIterator++)
-    {
-        ServiceBooking* booking = bookings.getValueAt(bookingIterator);
-        if (booking != nullptr &&
-            (booking->getCustomerId() == userID || booking->getAssignedTechnicianId() == userID))
-        {
-            if (booking->getStatus() == util::ServiceJobStatus::PENDING ||
-                booking->getStatus() == util::ServiceJobStatus::STARTED)
-            {
-                if (type == util::UserType::CUSTOMER)
-                {
-                    booking->setStatus(util::ServiceJobStatus::CANCELLED);
-                    booking->setCustomer(nullptr);
-                    booking->setCustomerId("");
-                    User* assignedTechnician = booking->getAssignedTechnician();
-                    sendNotification(assignedTechnician, "Customer Service Cancelled", "Uh?Oh. The customer has cancelled their service booking. Your assigned job card has been cancelled and the inventory has been restocked.");
-                }
-                else if (type == util::UserType::TECHNICIAN)
-                {
-                    booking->setStatus(util::ServiceJobStatus::PENDING);
-                    sendNotification(booking->getCustomer(), "Technician Unavailable", "Your assigned technician is no longer available. Your booking has been reset to pending, and we will reassign a new technician shortly.");
-                }
-                booking->setAssignedTechnician(nullptr);
-                booking->setAssignedTechnicianId("");
-                const auto& ListOfServices = booking->getServices();
-                for (int serviceIterator = 0; serviceIterator < ListOfServices.getSize(); serviceIterator++)
-                {
-                    Service* service = ListOfServices.getValueAt(serviceIterator);
-                    if (service != nullptr)
-                    {
-                        const auto& items = service->getRequiredInventoryItems();
-                        for (int itemIterator = 0; itemIterator < items.getSize(); itemIterator++)
-                        {
-                            InventoryItem* item = items.getValueAt(itemIterator);
-                            if (item != nullptr)
-                            {
-                                item->setQuantity(item->getQuantity() + INCREMENT_VALUE);
-                            }
-                        }
-                    }
-                }
-            }
 		}
 	}
 }
 
 /*
-Function: cancelTechnicianJobs
+Function: detach
-Description: Cancels all jobs assigned to a technician. Updates job status, sends notifications,
+Description: Detaches a user from the observer list of the ServiceManagementService.
-             and restocks inventory items used in the service.
+Parameters:
-Parameter: const std::string& technicianID - ID of the technician
+	- user: Pointer to the User object to be detached.
-Return type: void
+Returns:
+	- void
 */
-void ServiceManagementService::cancelTechnicianJobs(const std::string& technicianID)
+void ServiceManagementService::detach(User* user)
 {
-    const int INCREMENT_VALUE = 1;
+	if (user)
-    auto& jobs = m_dataStore.getJobCards();
-    for (int jobIterator = 0; jobIterator < jobs.getSize(); jobIterator++)
 	{
-        JobCard* job = jobs.getValueAt(jobIterator);
+		const std::string& userID = user->getId();
-        if (job != nullptr && job->getTechnicianId() == technicianID)
+		if (m_observers.find(userID) != -1)
 		{
-            if (job->getStatus() == util::ServiceJobStatus::PENDING || job->getStatus() == util::ServiceJobStatus::STARTED)
+			m_observers.remove(userID);
-            {
-                job->setStatus(util::ServiceJobStatus::CANCELLED);
-                sendNotification(job->getTechnician(), "Job Cancelled", "The Job has cancelled. Your job card has been cancelled and the inventory has been restocked.");
-                Service* service = job->getService();
-                if (service != nullptr)
-                {
-                    const auto& items = service->getRequiredInventoryItems();
-                    for (int itemIterator = 0; itemIterator < items.getSize(); itemIterator++)
-                    {
-                        InventoryItem* item = items.getValueAt(itemIterator);
-                        if (item != nullptr)
-                        {
-                            item->setQuantity(item->getQuantity() + INCREMENT_VALUE);
-                        }
-                    }
-                }
-            }
 		}
 	}
 }
 
 /*
-Function: createComboPackage
+Function: sendNotification
-Description: Creates a new combo package with two services and a discount percentage.
+Description: Sends a notification to a user if they are registered as an observer.
-             Validates service IDs, ensures uniqueness, and inserts the new package into the DataStore.
+Parameters:
-Parameter: const std::string& packageName - name of the combo package
+	- user: Pointer to the User object to receive the notification.
-           const util::Vector<std::string>& serviceIDsInNewCombo - list of service IDs
+	- title: Title of the notification.
-           double discountPercentage - discount percentage for the package
+	- message: Message content of the notification.
-Return type: void
+Returns:
+	- void
+Throws:
+	- std::runtime_error if notification creation fails.
 */
-void ServiceManagementService::createComboPackage(const std::string& packageName, const util::Vector<std::string>& serviceIDsInNewCombo, double discountPercentage)
+void ServiceManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
 {
-    if (packageName.empty())
+	if (user)
 	{
-        throw std::invalid_argument("The Combo Package Name cannot be empty.\n");
+		if (m_observers.find(user->getId()) != -1)
+		{
+			Notification* notification =
+				Factory::getObject<Notification>(
+					user->getId(),
+					user,
+					"ServiceManagementService: " + title,
+					message,
+					util::Timestamp()
+				);
+			if (notification)
+			{
+				user->addNotification(notification);
 			}
-    if (serviceIDsInNewCombo.getSize() < 2 || serviceIDsInNewCombo.getSize() > 2)
+			else
 			{
-        throw std::invalid_argument("Combo package must contain only two services.");
+				throw std::runtime_error("Failed to create notification");
-    }
-    if (discountPercentage < 0.0 || discountPercentage > 100.0)
-    {
-        throw std::invalid_argument("Discount percentage must be between 0 and 100.");
-    }
-    auto& servicesMap = m_dataStore.getServices();
-    for (int index = 0; index < serviceIDsInNewCombo.getSize(); index++)
-    {
-        const std::string serviceid = serviceIDsInNewCombo[index];
-        if (servicesMap.find(serviceid) == -1)
-        {
-            throw std::runtime_error("Service ID not found: " + serviceid);
 			}
 		}
-    auto& comboPackageMap = m_dataStore.getComboPackages();
-    for (int iterator = 0; iterator < comboPackageMap.getSize(); iterator++)
-    {
-        ComboPackage* existingCombos = comboPackageMap.getValueAt(iterator);
-        const util::Map<std::string, Service*>& servicesInsideExistingCombos = existingCombos->getServices();
-        if (servicesInsideExistingCombos.getSize() == serviceIDsInNewCombo.getSize())
-        {
-            bool isIdentical = true;
-            for (int serviceIterator = 0; serviceIterator < serviceIDsInNewCombo.getSize(); serviceIterator++)
-            {
-                const std::string& id = serviceIDsInNewCombo[serviceIterator];
-                if (servicesInsideExistingCombos.find(id) == -1)
-                {
-                    isIdentical = false;
-                    break;
-                }
-            }
-            if (isIdentical)
-            {
-                throw std::runtime_error("A combo package with the same services already exists.");
-            }
-        }
-    }
-    util::Map<std::string, Service*> selectedServices;
-    for (int iteratorOne = 0; iteratorOne < serviceIDsInNewCombo.getSize(); iteratorOne++)
-    {
-        const std::string& serviceId = serviceIDsInNewCombo[iteratorOne];
-        int serviceIndex = servicesMap.find(serviceId);
-        if (serviceIndex == -1)
-        {
-            throw std::runtime_error("Service ID not found: " + serviceId);
-        }
-        selectedServices.insert(serviceId, servicesMap.getValueAt(serviceIndex));
-    }
-    ComboPackage* newComboPackage = Factory::getObject<ComboPackage>(packageName, discountPercentage, selectedServices);
-    comboPackageMap.insert(newComboPackage->getId(), newComboPackage);
-}
-
-/*
-Function: getComboPackages
-Description: Retrieves all combo packages stored in the DataStore.
-Parameter: None
-Return type: util::Map<std::string, ComboPackage*>
-*/
-util::Map<std::string, ComboPackage*> ServiceManagementService::getComboPackages()
-{
-    return m_dataStore.getComboPackages();
-}
-
-/*
-Function: removeComboPackage
-Description: Removes a combo package by marking it inactive. Throws an exception if the package ID is not found.
-Parameter: const std::string& comboPackageID - ID of the combo package
-Return type: void
-*/
-void ServiceManagementService::removeComboPackage(const std::string& comboPackageID)
-{
-    bool removed = false;
-    util::Map<std::string, ComboPackage*>& currentComboPackages = m_dataStore.getComboPackages();
-    for (int iterator = 0; iterator < currentComboPackages.getSize(); iterator++)
-    {
-        ComboPackage* currentComboPackage = currentComboPackages.getValueAt(iterator);
-        if (currentComboPackage && currentComboPackage->getId() == comboPackageID)
-        {
-            currentComboPackage->setState(util::State::INACTIVE);
-            removed = true;
-            break;
-        }
-    }
-    if (!removed)
-    {
-        throw std::runtime_error("Combo package with ID '" + comboPackageID + "' not found.");
 	}
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/ServiceManagementService.h

@@ -1,11 +1,12 @@
 /*
 File: ServiceManagementService.h
-Description: Header file declaring the ServiceManagementService class, which manages
+Description: Declares the ServiceManagementService class which manages services, combo packages, service bookings, and job cards
-             services, combo packages, job cards, and service bookings. Inherits from
+             in the Vehicle Service Management System. Provides functionality to purchase services or packages, create and remove
-             NotificationManagementService to handle notifications.
+             services, assign and complete jobs, cancel bookings, and handle notifications using the Observer pattern.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
+
 #pragma once
 #include <string>
 #include "Map.h"
@@ -37,7 +38,7 @@ public:
     void completeJob(const std::string& jobID);
     void cancelCustomerServiceBookings(const std::string& customerID);
     void cancelTechnicianJobs(const std::string& technicianID);
-    void createComboPackage(const std::string& packageName, const util::Vector<std::string>& serviceIDs, double discountPercentage);
+    void createComboPackage(const std::string& name, const util::Vector<std::string>& serviceIDs, double discountPercentage);
     void removeComboPackage(const std::string& comboPackageID);
     void sendNotification(User* user, const std::string& title, const std::string& message) override;
     void attach(User* user) override;

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/UserManagementService.cpp

@@ -1,55 +1,75 @@
 /*
 File: UserManagementService.cpp
-Description: Implementation file containing the method definitions of the
+Description: Implements the UserManagementService class which manages user-related operations
-			 UserManagementService class, including user retrieval and removal logic.
+			 in the Vehicle Service Management System. Provides functionality for retrieving user notifications
+			 and deleting notifications by ID.
 Author: Trenser
-Date:19-May-2026
+Date: 20-May-2026
 */
+
+#include <stdexcept>
 #include "UserManagementService.h"
 #include "User.h"
+#include "Vector.h"
 
 /*
-Function: getUsers
+Function: getUserNotifications
-Description: Retrieves all users stored in the DataStore.
+Description: Retrieves all notifications associated with a given user ID.
-Parameter: None
+Parameters:
-Return type: util::Map<std::string, User*>
+	- 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::Map<std::string, User*> UserManagementService::getUsers()
+util::Vector<Notification*> UserManagementService::getUserNotifications(const std::string& userID)
 {
-	return m_dataStore.getUsers();
+	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: getUser
+Function: deleteNotification
-Description: Retrieves a specific user by ID from the DataStore.
+Description: Deletes a specific notification associated with a given user ID.
-Parameter: const std::string& userID - ID of the user
+Parameters:
-Return type: User*
+	- 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.
 */
-User* UserManagementService::getUser(const std::string& userID)
+void UserManagementService::deleteNotification(const std::string& notificationID, const std::string& userID)
 {
-	int index = m_dataStore.getUsers().find(userID);
+	auto& usersMap = m_dataStore.getUsers();
-	if (index != -1)
+	if (usersMap.find(userID) == -1)
 	{
-		return m_dataStore.getUsers().getValueAt(index);
+		throw std::runtime_error("No user found with given UserID");
-	}
-	return nullptr;
-}
-
-/*
-Function: removeUser
-Description: Marks a user as inactive in the DataStore instead of deleting them.
-Parameter: const std::string& userID - ID of the user to remove
-Return type: void
-*/
-void UserManagementService::removeUser(const std::string& userID)
-{
-	int index = m_dataStore.getUsers().find(userID);
-	if (index != -1)
-	{
-		User* user = m_dataStore.getUsers().getValueAt(index);
-		if (user != nullptr)
-		{
-			user->setState(util::State::INACTIVE);
-		}
 	}
+	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);
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/UserManagementService.h

@@ -1,10 +1,11 @@
 /*
 File: UserManagementService.h
-Description: Header file declaring the UserManagementService class, which manages
+Description: Declares the UserManagementService class which manages user-related operations in the Vehicle Service Management System.
-             user creation, updates, retrieval, removal, and notification handling.
+             Provides functionality to create, update, retrieve, and remove users, as well as manage user notifications.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
+
 #pragma once
 #include <string>
 #include "Map.h"
@@ -20,11 +21,11 @@ private:
     DataStore& m_dataStore;
 public:
     UserManagementService() : m_dataStore(DataStore::getInstance()) {}
-    void createUser(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone, util::UserType type);
+    void createUser(const std::string& username, const std::string& password, const std::string& email, const std::string& phone, util::UserType type);
     void updateUserDetails(const std::string& userID, const std::string& email, const std::string& phone);
     util::Map<std::string, User*> getUsers();
     util::Map<std::string, User*> getUsers(util::UserType type);
-    User* getUser(const std::string& userID);
+    User* getUser (const std::string& userID);
     void removeUser(const std::string& userID);
     util::Vector<Notification*> getUserNotifications(const std::string& userID);
     void deleteNotification(const std::string& notificationID, const std::string& userID);

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/Config.h

@@ -0,0 +1,18 @@
+/*
+File: Config.h
+Description: Defines configuration constants for system thresholds in the Vehicle Service Management System.
+			 Includes limits for inventory stock alerts and payment reminder intervals.
+Author: Trenser
+Date: 21-May-2026
+*/
+
+#pragma once
+
+namespace config
+{
+	namespace threshold
+	{
+		constexpr int INVENTORY_LOW_STOCK_THRESHOLD = 5;
+		constexpr int PAYMENT_REMINDER_THRESHOLD_HOURS = 168;
+	}
+}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/Enums.h

@@ -1,3 +1,12 @@
+/*
+File: Enums.h
+Description: Declares enumerations and utility functions for user types, payment modes, payment status,
+             service job status, and state management in the Vehicle Service Management System.
+             Provides string conversion and parsing functions for each enum type.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #pragma once
 #include <stdexcept>
 
@@ -24,10 +33,8 @@ namespace util
 
 	enum class ServiceJobStatus
 	{
-        PENDING,
 		STARTED,
-		COMPLETED,
+		COMPLETED
-        CANCELLED
 	};
 
     enum class State
@@ -36,6 +43,14 @@ namespace util
         INACTIVE
     };
 
+    /*
+    Function: getUserTypeString
+    Description: Converts a UserType enum value to its corresponding string representation.
+    Parameters:
+        - type: UserType enum value.
+    Returns:
+        - std::string representing the UserType.
+    */
     inline std::string getUserTypeString(UserType type)
     {
         switch (type)
@@ -50,6 +65,16 @@ namespace util
         throw std::invalid_argument("Invalid UserType");
     }
 
+    /*
+    Function: getUserType
+    Description: Converts a string value to its corresponding UserType enum.
+    Parameters:
+        - value: std::string representing the UserType.
+    Returns:
+        - UserType enum value.
+    Throws:
+        - std::invalid_argument if the string does not match a valid UserType.
+    */
     inline UserType getUserType(const std::string& value)
     {
         if (value == "ADMIN")
@@ -67,6 +92,14 @@ namespace util
         throw std::invalid_argument("Invalid UserType string");
     }
 
+    /*
+    Function: getPaymentModeString
+    Description: Converts a PaymentMode enum value to its corresponding string representation.
+    Parameters:
+        - mode: PaymentMode enum value.
+    Returns:
+        - std::string representing the PaymentMode.
+    */
     inline std::string getPaymentModeString(PaymentMode mode)
     {
         switch (mode)
@@ -79,6 +112,16 @@ namespace util
         throw std::invalid_argument("Invalid PaymentMode");
     }
 
+    /*
+    Function: getPaymentMode
+    Description: Converts a string value to its corresponding PaymentMode enum.
+    Parameters:
+        - value: std::string representing the PaymentMode.
+    Returns:
+        - PaymentMode enum value.
+    Throws:
+        - std::invalid_argument if the string does not match a valid PaymentMode.
+    */
     inline PaymentMode getPaymentMode(const std::string& value)
     {
         if (value == "ONLINE")
@@ -92,6 +135,14 @@ namespace util
         throw std::invalid_argument("Invalid PaymentMode string");
     }
 
+    /*
+    Function: getPaymentStatusString
+    Description: Converts a PaymentStatus enum value to its corresponding string representation.
+    Parameters:
+        - status: PaymentStatus enum value.
+    Returns:
+        - std::string representing the PaymentStatus.
+    */
     inline std::string getPaymentStatusString(PaymentStatus status)
     {
         switch (status)
@@ -104,6 +155,16 @@ namespace util
         throw std::invalid_argument("Invalid PaymentStatus");
     }
 
+    /*
+    Function: getPaymentStatus
+    Description: Converts a string value to its corresponding PaymentStatus enum.
+    Parameters:
+        - value: std::string representing the PaymentStatus.
+    Returns:
+        - PaymentStatus enum value.
+    Throws:
+        - std::invalid_argument if the string does not match a valid PaymentStatus.
+    */
     inline PaymentStatus getPaymentStatus(const std::string& value)
     {
         if (value == "PENDING")
@@ -119,22 +180,36 @@ namespace util
         throw std::invalid_argument("Invalid PaymentStatus string");
     }
 
+    /*
+    Function: getServiceJobStatusString
+    Description: Converts a ServiceJobStatus enum value to its corresponding string representation.
+    Parameters:
+        - status: ServiceJobStatus enum value.
+    Returns:
+        - std::string representing the ServiceJobStatus.
+    */
     inline std::string getServiceJobStatusString(ServiceJobStatus status)
     {
         switch (status)
         {
-        case ServiceJobStatus::PENDING:
-            return "PENDING";
         case ServiceJobStatus::STARTED:
             return "STARTED";
         case ServiceJobStatus::COMPLETED:
             return "COMPLETED";
-        case ServiceJobStatus::CANCELLED:
-            return "CANCELLED";
         }
         throw std::invalid_argument("Invalid ServiceJobStatus");
     }
 
+    /*
+    Function: getServiceJobStatus
+    Description: Converts a string value to its corresponding ServiceJobStatus enum.
+    Parameters:
+        - value: std::string representing the ServiceJobStatus.
+    Returns:
+        - ServiceJobStatus enum value.
+    Throws:
+        - std::invalid_argument if the string does not match a valid ServiceJobStatus.
+    */
     inline ServiceJobStatus getServiceJobStatus(const std::string& value)
     {
         if (value == "STARTED")
@@ -145,17 +220,17 @@ namespace util
         {
             return ServiceJobStatus::COMPLETED;
         }
-        if (value == "PENDING")
-        {
-            return ServiceJobStatus::PENDING;
-        }
-        if (value == "CANCELLED")
-        {
-            return ServiceJobStatus::CANCELLED;
-        }
         throw std::invalid_argument("Invalid ServiceJobStatus string");
     }
 
+    /*
+    Function: getStateString
+    Description: Converts a State enum value to its corresponding string representation.
+    Parameters:
+        - status: State enum value.
+    Returns:
+        - std::string representing the State.
+    */
     inline std::string getStateString(State status)
     {
         switch (status)
@@ -168,6 +243,16 @@ namespace util
         throw std::invalid_argument("Invalid State");
     }
 
+    /*
+    Function: getState
+    Description: Converts a string value to its corresponding State enum.
+    Parameters:
+        - value: std::string representing the State.
+    Returns:
+        - State enum value.
+    Throws:
+        - std::invalid_argument if the string does not match a valid State.
+    */
     inline State getState(const std::string& value)
     {
         if (value == "ACTIVE")

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/Utility.h

@@ -1,29 +1,8 @@
 /*
 File: Utility.h
-Description: Header file declaring utility functions used across the system,
+Description:
-             including cost calculation for services based on required inventory items.
 Author: Trenser
-Date:19-May-2026
+Date: 20-May-2026
 */
-#pragma once
-#include "Service.h"
-#include "InventoryItem.h"
 
-/*
+#pragma once
-Function: calculatePartsCost
-Description: Calculates the total cost of parts required for a given service
-             by summing the prices of all associated inventory items.
-Parameter: const Service* service - pointer to the service object
-Return type: double - total cost of required parts
-*/
-inline double calculatePartsCost(const Service* service)
-{
-    double cost = 0;
-    auto& requiredInventoryItems = service->getRequiredInventoryItems();
-    int requiredInventoryItemsSize = requiredInventoryItems.getSize();
-    for (int index = 0; index < requiredInventoryItemsSize; index++)
-    {
-        cost += requiredInventoryItems.getValueAt(index)->getPrice();
-    }
-    return cost;
-}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/AdminMenu.cpp

@@ -1,57 +1,41 @@
 /*
 File: AdminMenu.cpp
-Description: Implementation file containing the method definitions of the
+Description: Implements the AdminMenu class which provides the administrator’s console interface
-			 AdminMenu class, including menu handling, inventory operations,
+			 in the Vehicle Service Management System. Handles menu display, user input, and
-			 user management, and combo package management functions.
+			 admin-specific operations such as inventory management, technician management,
+			 service creation, combo package management, job assignment, and notifications.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
-#include <iostream>
+
-#include <iomanip>
 #include "AdminMenu.h"
 #include "InputHelper.h"
 #include "OutputHelper.h"
-#include "User.h"
+#include "MenuHelper.h"
-#include "Validator.h"
-#include "Service.h"
-#include "Utility.h"
-#include "ComboPackage.h"
-#include "Enums.h"
 
 /*
 Function: showMenu
-Description: Displays the admin menu and handles user input until logout is selected.
+Description: Displays the admin menu in a loop until the user chooses to logout.
-Parameter: None
+			 Handles exceptions and ensures smooth user interaction.
-Return type: void
+Parameters:
+	- None
+Returns:
+	- void
 */
 void AdminMenu::showMenu()
 {
-    while (true)
+	bool isMenuActive = true;
+	while (isMenuActive)
 	{
 		try
 		{
 			int choice;
 			util::clear();
-            std::cout << "Admin Menu"
+			std::cout << "" << std::endl;
-                << "\n1. View Stock Levels"
-                << "\n2. Add Inventory Item"
-                << "\n3. Remove Inventory Item"
-                << "\n4. Check Stock Availability"
-                << "\n5. Assign Job to Technician"
-                << "\n6. Add Technician"
-                << "\n7. Remove Customer/Technician"
-                << "\n8. Create Service"
-                << "\n9. Remove Service"
-                << "\n10. Create Combo Package"
-                << "\n11. Remove Combo Package"
-                << "\n12. View Notifications"
-                << "\n13. Change Password"
-                << "\n14. Logout"
-                << "\nEnter a choice: ";
 			util::read(choice);
 			if (!handleOperation(choice))
 			{
-                break;
+				isMenuActive = false;
 			}
 		}
 		catch (const std::exception& e)
@@ -62,100 +46,18 @@ void AdminMenu::showMenu()
 	}
 }
 
-/*
-Function: handleOperation
-Description: Executes the corresponding admin operation based on the selected menu choice.
-Parameter: int choice - selected menu option
-Return type: bool - true if menu continues, false if logout
-*/
 bool AdminMenu::handleOperation(int choice)
 {
-    switch (choice)
-    {
-    case 1:
-        viewStockLevels();
-        break;
-    case 2:
-        addInventoryItem();
-        break;
-    case 3:
-        removeInventoryItem();
-        break;
-    case 4:
-        checkStockAvailability();
-        break;
-    case 5:
-        assignJob();
-        break;
-    case 6:
-        addTechnician();
-        break;
-    case 7:
-        removeUser();
-        break;
-    case 8:
-        createService();
-        break;
-    case 9:
-        removeService();
-        break;
-    case 10:
-        createComboPackages();
-        break;
-    case 11:
-        removeComboPackage();
-        break;
-    case 12:
-        viewNotifications();
-        break;
-    case 13:
-        changePassword();
-        break;
-    case 14:
-        logout();
 	return false;
-    default:
-        std::cout << "Enter a valid choice!" << std::endl;
-        util::pressEnter();
-    }
-    return true;
 }
 
-/*
+
-Function: logout
-Description: Logs out the currently authenticated admin user.
-Parameter: None
-Return type: void
-*/
 void AdminMenu::logout()
 {
-	m_controller.logout();
 }
-/*
+
-Function: changePassword
-Description: Allows the admin to change their password after validation.
-Parameter: None
-Return type: void
-*/
 void AdminMenu::changePassword()
 {
-	std::string newPassword;
-	while (true)
-	{
-		util::clear();
-		std::cout << "Enter new password: ";
-		util::read(newPassword);
-		if (!util::isPasswordValid(newPassword))
-		{
-			std::cout << "Error: Password is not strong enough!\n";
-			util::pressEnter();
-			continue;
-		}
-		m_controller.changePassword(newPassword);
-		std::cout << "Password changed successfully\n";
-		util::pressEnter();
-		break;
-	}
 }
 
 void AdminMenu::viewStockLevels()
@@ -186,331 +88,31 @@ void AdminMenu::removeService()
 {
 }
 
-/*
-Function: addTechnician
-Description: Adds a new technician after validating username, password, email, and phone number.
-Parameter: None
-Return type: void
-*/
 void AdminMenu::addTechnician()
 {
-	util::clear();
-	std::string username, name, password, email, phoneNumber;
-	std::cout << std::left << std::setw(25) << "Enter Technician Username: ";
-	util::read(username);
-	std::cout << std::left << std::setw(25) << "Enter Technician Name: ";
-	util::read(name);
-	std::cout << std::setw(25) << "Enter Technician Password: ";
-	util::read(password);
-	if(!util::isPasswordValid(password))
-	{
-		std::cout << "Error: Password is invalid!";
-		util::pressEnter();
-		return;
-	}
-	std::cout << std::setw(25) << "Enter Technician Email: ";
-	util::read(email);
-	if(!util::isEmailValid(email))
-	{
-		std::cout << "Error: Email is invalid!";
-		util::pressEnter();
-		return;
-	}
-	std::cout << std::setw(25) << "Enter Technician Phone: ";
-	util::read(phoneNumber);
-	if(!util::isPhoneNumberValid(phoneNumber))
-	{
-		std::cout << "Error: Phone Number is invalid!";
-		util::pressEnter();
-		return;
-	}
-	m_controller.createTechnician(username, name, password, email, phoneNumber);
-	std::cout << "\nTechnician Added Successfully.\n";
-	util::pressEnter();
 }
 
-/*
-Function: filterActiveUsers
-Description: Filters out inactive users and returns a map of active users.
-Parameter: const util::Map<std::string, const User*>& listOfUsers - all users
-Return type: util::Map<std::string, const User*>
-*/
-static util::Map<std::string, const User*>
-filterActiveUsers(const util::Map<std::string, const User*>& listOfUsers)
-{
-	util::Map<std::string, const User*> activeUsers;
-	int inventorySize = listOfUsers.getSize();
-	for (int index = 0; index < inventorySize; index++)
-	{
-		const User* user = listOfUsers.getValueAt(index);
-		if (user != nullptr && user->getState() != util::State::INACTIVE)
-		{
-			activeUsers.insert(user->getId(), user);
-		}
-	}
-	return activeUsers;
-}
-
-/*
-Function: displayAllActiveUsers
-Description: Displays all active users in a tabular format with index, ID, username, and type.
-Parameter: util::Map<std::string, const User*>& activeUsers - active users list
-		   int activeUserCount - number of active users
-Return type: void
-*/
-static void displayAllActiveUsers(util::Map<std::string, const User*>& activeUsers, int activeUserCount)
-{
-	std::cout << std::left << std::setw(10) << "Index"
-		<< std::setw(15) << "User ID"
-		<< std::setw(25) << "Username"
-		<< std::setw(25) << "User Type"
-		<< std::endl;
-	for (int iterator = 0; iterator < activeUserCount; iterator++)
-	{
-		const User* user = activeUsers.getValueAt(iterator);
-		if (user != nullptr)
-		{
-			std::cout << std::left << std::setw(10) << (iterator + 1)
-				<< std::setw(15) << user->getId()
-				<< std::setw(25) << user->getUserName()
-				<< std::setw(25) << util::getUserTypeString(user->getUserType())
-				<< std::endl;
-		}
-		else
-		{
-			std::cout << "No users found.\n";
-			util::pressEnter();
-			return;
-		}
-	}
-}
-
-/*
-Function: removeUser
-Description: Removes a selected active user (customer or technician) from the system.
-Parameter: None
-Return type: void
-*/
 void AdminMenu::removeUser()
 {
-	util::clear();
-	int indexChoice;
-	auto listOfUsers = m_controller.getUsers();
-	auto listOfActiveUsers = filterActiveUsers(listOfUsers);
-	int activeUserCount = listOfActiveUsers.getSize();
-	if (activeUserCount < 1)
-	{
-		std::cout << "No Active users." << std::endl;
-		util::pressEnter();
-		return;
-	}
-	displayAllActiveUsers(listOfActiveUsers, activeUserCount);
-	std::cout << "Enter the index of the user to delete : ";
-	util::read(indexChoice);
-	if (indexChoice < 1 || indexChoice > activeUserCount)
-	{
-		std::cout << "Error Invaild index.\n" << std::endl;
-		util::pressEnter();
-		return;
-	}
-	const User* userToRemove = listOfActiveUsers.getValueAt(indexChoice - 1);
-	if (userToRemove != nullptr)
-	{
-		std::string userIdToRemove = userToRemove->getId();
-		m_controller.removeUser(userIdToRemove);
-		std::cout << userToRemove->getUserName() << " removed Successfully.\n";
-	}
-	util::pressEnter();
 }
 
-/*
-Function: selectServiceFromServices
-Description: Displays active services and allows the admin to select one by index.
-Parameter: const util::Map<std::string, const Service*>& services - list of services
-Return type: const Service* - selected service
-*/
-static const Service* selectServiceFromServices(const util::Map<std::string, const Service*>& services)
-{
-    util::Map<int, const Service*> activeServicesMap;
-    int currentIndex = 1;
-    int userInputIndex;
-    std::cout << std::left
-        << std::setw(10) << "Index"
-        << std::setw(15) << "Service ID"
-        << std::setw(25) << "Service Name"
-        << std::setw(15) << "Estimated Cost"
-        << std::endl;
-    for (int index = 0; index < services.getSize(); index++)
-    {
-        const Service* currentService = services.getValueAt(index);
-        if (currentService->getState() != util::State::ACTIVE)
-        {
-            continue;
-        }
-        activeServicesMap.insert(currentIndex, currentService);
-        double partsCost = calculatePartsCost(currentService);
-        std::cout << std::left
-            << std::setw(10) << currentIndex
-            << std::setw(15) << currentService->getId()
-            << std::setw(25) << currentService->getName()
-            << std::setw(15) << (currentService->getLaborCost() + partsCost)
-            << std::endl;
-        currentIndex++;
-    }
-    if (activeServicesMap.getSize() == 0)
-    {
-        std::cout << "No active services available." << std::endl;
-        return nullptr;
-    }
-    std::cout << "Enter service index: ";
-    util::read(userInputIndex);
-    if (activeServicesMap.find(userInputIndex) == -1)
-    {
-        std::cout << "Invalid service index." << std::endl;
-        return nullptr;
-    }
-    return activeServicesMap[userInputIndex];
-}
-
-/*
-Function: createComboPackages
-Description: Creates a new combo package by selecting two active services and applying a discount.
-Parameter: None
-Return type: void
-*/
 void AdminMenu::createComboPackages()
 {
-	util::clear();
-	auto serviceList = m_controller.getServices();
-    const int numberOfServicesInPackage = 2;
-	util::Vector<std::string> selectedServiceID;
-    for (int iterator = 0; iterator < numberOfServicesInPackage; iterator++)
-    {
-        const Service* chosenService = selectServiceFromServices(serviceList);
-        if (chosenService == nullptr)
-        {
-            std::cout << "Failed to create combo package!";
-            util::pressEnter();
-            return;
-        }
-        selectedServiceID.push_back(chosenService->getId());
-        util::clear();
-    }
-    std::string packageName;
-    double discountPercentage;
-    std::cout << "Enter combo package name: ";
-    util::read(packageName);
-    std::cout << "Enter discount percentage: ";
-    util::read(discountPercentage);
-    if (discountPercentage < 0.0 || discountPercentage > 100.0)
-    {
-        std::cout << "Error: Discount percentage must be between 0 and 100." << std::endl;
-        util::pressEnter();
-        return;
-    }
-    m_controller.createComboPackage(packageName, selectedServiceID, discountPercentage);
-    std::cout << "Combo package '" << packageName << "' created successfully." << std::endl;
-    util::pressEnter();
 }
 
-/*
-Function: displayComboPackagesWithIndex
-Description: Displays combo packages with index, ID, name, and discount percentage.
-Parameter: util::Map<int, const ComboPackage*>& currentComboPackageIndexMap - combo packages map
-Return type: void
-*/
-static void displayComboPackagesWithIndex(util::Map<int, const ComboPackage*>& currentComboPackageIndexMap)
-{
-	for (int iterator = 0; iterator < currentComboPackageIndexMap.getSize(); iterator++)
-	{
-		const ComboPackage* currentComboPackage = currentComboPackageIndexMap.getValueAt(iterator);
-		if (currentComboPackage == nullptr)
-		{
-			throw std::runtime_error("Error accessing the combopackage.\n");
-		}
-		if (iterator == 0)
-		{
-			std::cout << std::left
-				<< std::setw(8) << "Index"
-				<< std::setw(10) << "ID"
-				<< std::setw(20) << "Package Name"
-				<< std::setw(15) << "Discount (%)"
-				<< "\n";
-		}
-		std::cout << std::left
-			<< std::setw(8) << currentComboPackageIndexMap.getKeyAt(iterator)
-			<< std::setw(10) << currentComboPackage->getId()
-			<< std::setw(20) << currentComboPackage->getPackageName()
-			<< std::setw(15) << currentComboPackage->getDiscountPercentage()
-			<< "\n";
-	}
-}
-
-/*
-Function: selectComboPackage
-Description: Allows the admin to select an active combo package by index.
-Parameter: util::Map<std::string, const ComboPackage*>& currentComboPackages - combo packages list
-Return type: std::string - ID of the selected combo package
-*/
-static std::string selectComboPackage(util::Map<std::string, const ComboPackage*>& currentComboPackages)
-{
-	util::Map<int, const ComboPackage*> currentComboPackageIndexMap;
-	if (currentComboPackages.getSize() == 0)
-	{
-		throw std::runtime_error("No combo packages are available.\n");
-	}
-	int currentIndex = 1, choice, selectedIndex;
-	for (int iterator = 0; iterator < currentComboPackages.getSize(); iterator++)
-	{
-		if (currentComboPackages.getValueAt(iterator)->getState() == util::State::INACTIVE)
-		{
-			continue;
-		}
-		currentComboPackageIndexMap.insert(currentIndex++, currentComboPackages.getValueAt(iterator));
-	}
-	if (currentComboPackageIndexMap.getSize() == 0)
-	{
-		throw std::runtime_error("No combo packages currently active.");
-	}
-	displayComboPackagesWithIndex(currentComboPackageIndexMap);
-	std::cout << "Enter your choice(Index): ";
-	util::read(choice);
-	selectedIndex = currentComboPackageIndexMap.find(choice);
-	if (selectedIndex != -1)
-	{
-		std::string selectedComboPackageID = currentComboPackageIndexMap.getValueAt(selectedIndex)->getId();
-		return selectedComboPackageID;
-	}
-	else
-	{
-		std::cout << "Enter a valid choice.\n";
-		return "";
-	}
-}
-
-/*
-Function: removeComboPackage
-Description: Removes a selected combo package from the system.
-Parameter: None
-Return type: void
-*/
 void AdminMenu::removeComboPackage()
 {
-	util::clear();
-	util::Map<std::string, const ComboPackage*> currentComboPackages = m_controller.getComboPackages();
-	std::string selectedComboPackageID = selectComboPackage(currentComboPackages);
-	if (selectedComboPackageID != "")
-	{
-		m_controller.removeComboPackage(selectedComboPackageID);
-		std::cout << "Combo Package removed successfully.\n";
-	}
-	else
-	{
-		std::cout << "Combo package removal failed.\n";
-	}
-	util::pressEnter();
 }
 
+/*
+Function: viewNotifications
+Description: Displays notifications for the admin and allows deletion of notifications.
+Parameters:
+	- None
+Returns:
+	- void
+*/
 void AdminMenu::viewNotifications()
 {
+	viewAndDeleteNotification(m_controller);
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/AdminMenu.h

@@ -1,11 +1,12 @@
 /*
 File: AdminMenu.h
-Description: Header file declaring the AdminMenu class, which provides
+Description: Declares the AdminMenu class which provides the administrative console menu in the Vehicle Service Management System.
-             administrative operations such as inventory management,
+             Supports operations such as inventory management, job assignment, service creation/removal, technician management,
-             user management, service configuration, and notifications.
+             combo package handling, notification viewing, and account management functions like logout and password change.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
+
 #pragma once
 #include "Controller.h"
 

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/CustomerMenu.cpp

@@ -1,7 +1,27 @@
+/*
+File: CustomerMenu.cpp
+Description: Implements the CustomerMenu class which provides the customer’s console interface
+             in the Vehicle Service Management System. Handles menu display, user input, and
+             customer-specific operations such as booking services, viewing history, managing payments,
+             invoices, and notifications.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #include "CustomerMenu.h"
 #include "InputHelper.h"
 #include "OutputHelper.h"
+#include "MenuHelper.h"
 
+/*
+Function: showMenu
+Description: Displays the customer menu in a loop until the user chooses to logout.
+             Handles exceptions and ensures smooth user interaction.
+Parameters:
+    - None
+Returns:
+    - void
+*/
 void CustomerMenu::showMenu()
 {
 	bool isMenuActive = true;
@@ -63,10 +83,66 @@ void CustomerMenu::viewInvoices()
 {
 }
 
+/*
+Function: viewNotifications
+Description: Displays notifications for the customer and allows deletion of notifications.
+Parameters:
+    - None
+Returns:
+    - void
+*/
 void CustomerMenu::viewNotifications()
 {
+	viewAndDeleteNotification(m_controller);
 }
 
+/*
+Function: getNotificationPreference (static helper)
+Description: Helper function to configure notification preferences for a specific service.
+Parameters:
+    - serviceName: Name of the service for which notifications are being configured.
+Returns:
+    - bool: True if notifications are enabled, False if disabled.
+*/
+static bool getNotificationPreference(const std::string& serviceName)
+{
+    int choice;
+    while (true)
+    {
+        util::clear();
+        std::cout << "    Configure Notification Preferences\n";
+        std::cout << "\n" << serviceName << " Notifications\n";
+        std::cout << "1. Enable Notifications\n";
+        std::cout << "2. Disable Notifications\n";
+        std::cout << "Enter your choice: ";
+        util::read(choice);
+        if (choice == 1)
+        {
+            return true;
+        }
+        if (choice == 2)
+        {
+            return false;
+        }
+        std::cout << "\nInvalid choice. Please enter 1 or 2.\n";
+        util::pressEnter();
+    }
+}
+
+/*
+Function: configureNotifications
+Description: Allows the customer to configure notification preferences for payment and service management.
+Parameters:
+    - None
+Returns:
+    - void
+*/
 void CustomerMenu::configureNotifications()
 {
+    bool paymentServiceNotifications = getNotificationPreference("Payment Management Service");
+    bool serviceManagementNotifications = getNotificationPreference("Service Management Service");
+    m_controller.configureNotifications(paymentServiceNotifications, serviceManagementNotifications);
+    util::clear();
+    std::cout << "Notification preferences updated successfully.\n";
+    util::pressEnter();
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/CustomerMenu.h

@@ -1,3 +1,12 @@
+/*
+File: CustomerMenu.h
+Description: Declares the CustomerMenu class which provides the customer-facing console menu in the Vehicle Service Management System.
+             Supports operations such as account management, service selection, combo package booking, viewing service history,
+             handling payments and invoices, and managing notifications.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #pragma once
 #include "Controller.h"
 

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/MenuHelper.h

@@ -0,0 +1,114 @@
+/*
+File: MenuHelper.h
+Description: Provides inline utility functions to support menu operations in the Vehicle Service Management System.
+             Includes helper functions for selecting, displaying, and managing notifications, as well as
+             integrating with the controller for user interactions.
+Author: Trenser
+Date: 21-May-2026
+*/
+
+#pragma once
+#include <iomanip>
+#include "Vector.h"
+#include "Controller.h"
+#include "Notification.h"
+#include "InputHelper.h"
+#include "OutputHelper.h"
+
+/*
+Function: selectNotification
+Description: Displays a list of notifications with index, ID, title, and timestamp,
+             then allows the user to select one by index.
+Parameters:
+    - notifications: Vector of Notification pointers to be displayed.
+Returns:
+    - const Notification* representing the selected notification.
+    - nullptr if no notifications are available or if the selection is invalid.
+*/
+inline const Notification* selectNotification(const util::Vector<const Notification*>& notifications)
+{
+    if (notifications.getSize() == 0)
+    {
+        std::cout << "No notifications available." << std::endl;
+        return nullptr;
+    }
+    util::Map<int, const Notification*> indexedNotifications;
+    std::cout << std::left
+        << std::setw(6) << "Index"
+        << std::setw(15) << "ID"
+        << std::setw(30) << "Title"
+        << std::setw(25) << "Timestamp"
+        << std::endl;
+    int currentIndex = 1;
+    for (int index = 0; index < notifications.getSize(); index++)
+    {
+        const Notification* currentNotification = notifications[index];
+        if (currentNotification)
+        {
+            std::cout << std::left
+                << std::setw(6) << currentIndex
+                << std::setw(15) << currentNotification->getId()
+                << std::setw(30) << currentNotification->getTitle()
+                << std::setw(25) << currentNotification->getCreatedAt().toString()
+                << std::endl;
+            indexedNotifications.insert(currentIndex, currentNotification);
+            currentIndex++;
+        }
+    }
+    int selectedIndex;
+    std::cout << "Select notification: ";
+    util::read(selectedIndex);
+    if (!indexedNotifications.containsKey(selectedIndex))
+    {
+        std::cout << "Invalid selection." << std::endl;
+        return nullptr;
+    }
+    return indexedNotifications[selectedIndex];
+}
+
+/*
+Function: displayNotification
+Description: Displays detailed information about a single notification, including ID, title, timestamp, and message.
+Parameters:
+    - notification: Pointer to the Notification object to be displayed.
+Returns:
+    - void
+*/
+inline void displayNotification(const Notification* notification)
+{
+    util::clear();
+    if (!notification)
+    {
+        std::cout << "Notification not found." << std::endl;
+        return;
+    }
+    std::cout << "Notification Details" << std::endl;
+    std::cout << "ID        : " << notification->getId() << std::endl;
+    std::cout << "Title     : " << notification->getTitle() << std::endl;
+    std::cout << "Timestamp : " << notification->getCreatedAt().toString() << std::endl;
+    std::cout << "Message   : " << notification->getMessage() << std::endl;
+}
+
+/*
+Function: viewAndDeleteNotification
+Description: Allows the user to view a notification and then delete it from the system using the controller.
+Parameters:
+    - controller: Reference to the Controller object used to manage notifications.
+Returns:
+    - void
+*/
+inline void viewAndDeleteNotification(Controller& controller)
+{
+    util::clear();
+	auto notifications = controller.getNotifications();
+	const Notification* selectedNotification = selectNotification(notifications);
+	if (!selectedNotification)
+	{
+		std::cout << "Failed to display notification!";
+		util::pressEnter();
+		return;
+	}
+	displayNotification(selectedNotification);
+    controller.deleteNotification(selectedNotification->getId());
+    util::pressEnter();
+}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/TechnicianMenu.cpp

@@ -1,40 +1,40 @@
 /*
 File: TechnicianMenu.cpp
-Description: Implementation file containing the method definitions of the
+Description: Implements the TechnicianMenu class which provides the technician’s console interface
-             TechnicianMenu class, including menu handling, job completion,
+			 in the Vehicle Service Management System. Handles menu display, user input, and
-             notification viewing, password management, and logout logic.
+			 technician-specific operations such as completing jobs and viewing notifications.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
+
 #include "TechnicianMenu.h"
 #include "InputHelper.h"
 #include "OutputHelper.h"
-#include "Validator.h"
+#include "MenuHelper.h"
 
 /*
 Function: showMenu
-Description: Displays the technician menu and handles user input until logout is selected.
+Description: Displays the technician menu in a loop until the user chooses to logout.
-Parameter: None
+			 Handles exceptions and ensures smooth user interaction.
-Return type: void
+Parameters:
+	- None
+Returns:
+	- void
 */
 void TechnicianMenu::showMenu()
 {
-    while (true)
+	bool isMenuActive = true;
+	while (isMenuActive)
 	{
 		try
 		{
 			int choice;
 			util::clear();
-            std::cout << "Technician Menu"
+			std::cout << "" << std::endl;
-                << "\n1. Mark Job as Completed"
-                << "\n2. View Notifications"
-                << "\n3. Change Password"
-                << "\n4. Logout"
-                << "\nEnter a choice: ";
 			util::read(choice);
 			if (!handleOperation(choice))
 			{
-                break;
+				isMenuActive = false;
 			}
 		}
 		catch (const std::exception& e)
@@ -45,78 +45,24 @@ void TechnicianMenu::showMenu()
 	}
 }
 
-/*
-Function: handleOperation
-Description: Executes the corresponding technician operation based on the selected menu choice.
-Parameter: int choice - selected menu option
-Return type: bool - true if menu continues, false if logout
-*/
 bool TechnicianMenu::handleOperation(int choice)
 {
-    switch (choice)
-    {
-    case 1:
-        completeJob();
-        break;
-    case 2:
-        viewNotifications();
-        break;
-    case 3:
-        changePassword();
-        break;
-    case 4:
-        logout();
 	return false;
-    default:
-        std::cout << "Enter a valid choice!" << std::endl;
-        util::pressEnter();
-    }
-    return true;
 }
 
-
 void TechnicianMenu::completeJob()
 {
 }
 
+/*
+Function: viewNotifications
+Description: Displays notifications for the technician and allows deletion of notifications.
+Parameters:
+	- None
+Returns:
+	- void
+*/
 void TechnicianMenu::viewNotifications()
 {
-}
+	viewAndDeleteNotification(m_controller);
-
-/*
-Function: logout
-Description: Logs out the currently authenticated technician user.
-Parameter: None
-Return type: void
-*/
-void TechnicianMenu::logout()
-{
-	m_controller.logout();
-}
-
-/*
-Function: changePassword
-Description: Allows the technician to change their password after validation.
-Parameter: None
-Return type: void
-*/
-void TechnicianMenu::changePassword()
-{
-	std::string newPassword;
-	while (true)
-	{
-		util::clear();
-		std::cout << "Enter new password: ";
-		util::read(newPassword);
-		if (!util::isPasswordValid(newPassword))
-		{
-			std::cout << "Error: Password is not strong enough!\n";
-			util::pressEnter();
-			continue;
-		}
-		m_controller.changePassword(newPassword);
-		std::cout << "Password changed successfully\n";
-		util::pressEnter();
-		break;
-	}
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/TechnicianMenu.h

@@ -1,11 +1,11 @@
 /*
 File: TechnicianMenu.h
-Description: Header file declaring the TechnicianMenu class, which provides
+Description: Declares the TechnicianMenu class which provides the technician-facing console menu in the Vehicle Service Management System.
-             technician operations such as job completion, notification viewing,
+             Supports operations such as viewing assigned jobs, completing jobs, and managing notifications.
-             password management, and logout functionality.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
+
 #pragma once
 #include "Controller.h"
 
@@ -18,6 +18,4 @@ public:
     void showMenu();
     void completeJob();
     void viewNotifications();
-    void logout();
-    void changePassword();
 };

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/UserInterface.cpp

@@ -1,25 +1,27 @@
 /*
 File: UserInterface.cpp
-Description: Implementation file containing the method definitions of the
+Description: Implements the UserInterface class which provides the main entry point for the Vehicle Service Management System.
-			 UserInterface class, including system run loop, login handling,
+			 Handles system checks, displays the main menu, and manages user operations such as login and customer registration.
-			 and customer registration logic.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
+
 #include "UserInterface.h"
 #include "InputHelper.h"
 #include "OutputHelper.h"
-#include "User.h"
 
 /*
 Function: run
-Description: Runs the main system loop, displaying the initial menu for login,
+Description: Runs the Vehicle Service Management System interface.
-			 customer registration, or exit. Handles exceptions gracefully.
+			 Performs system checks, displays the main menu, and processes user input until exit.
-Parameter: None
+Parameters:
-Return type: void
+	- None
+Returns:
+	- void
 */
 void UserInterface::run()
 {
+	m_controller.runSystemChecks();
 	bool isMenuActive = true;
 	while (isMenuActive)
 	{
@@ -44,9 +46,11 @@ void UserInterface::run()
 
 /*
 Function: handleOperation
-Description: Executes the corresponding system operation based on the selected menu choice.
+Description: Processes the user’s menu choice and executes the corresponding action.
-Parameter: int choice - selected menu option
+Parameters:
-Return type: bool - true if menu continues, false if exit
+	- choice: Integer representing the selected menu option.
+Returns:
+	- bool: True if the menu should remain active, False if exit is selected.
 */
 bool UserInterface::handleOperation(int choice)
 {
@@ -70,47 +74,25 @@ bool UserInterface::handleOperation(int choice)
 
 /*
 Function: login
-Description: Handles user login by validating credentials. Based on the authenticated
+Description: Handles the login process for existing users.
-			 user type, navigates to the appropriate menu (Admin, Technician, Customer).
+Parameters:
-Parameter: None
+	- None
-Return type: void
+Returns:
+	- void
 */
 void UserInterface::login()
 {
-	std::string username, password;
+
-	util::clear();
-	std::cout << "Enter username: ";
-	util::read(username);
-	std::cout << "Enter password: ";
-	util::read(password);
-	if (m_controller.login(username, password))
-	{
-		const User* authenticatedUser = m_controller.getAuthenticatedUser();
-		if (authenticatedUser != nullptr)
-		{
-			switch (authenticatedUser->getUserType())
-			{
-			case util::UserType::ADMIN:
-				m_adminMenu.showMenu();
-				break;
-			case util::UserType::TECHNICIAN:
-				m_technicianMenu.showMenu();
-				break;
-			case util::UserType::CUSTOMER:
-				m_customerMenu.showMenu();
-				break;
-			default:
-				std::cout << "\nError: Unknown user type";
-				break;
-			}
-		}
-	}
-	else
-	{
-		std::cout << "\nError: Invalid Username or Password";
-	}
 }
 
+/*
+Function: registerCustomer
+Description: Handles the registration process for new customers.
+Parameters:
+	- None
+Returns:
+	- void
+*/
 void UserInterface::registerCustomer()
 {
 

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/UserInterface.h

@@ -1,12 +1,12 @@
 /*
 File: UserInterface.h
-Description: Header file declaring the UserInterface class, which provides
+Description: Declares the UserInterface class which provides the main console interface for the Vehicle Service Management System.
-             the main entry point for the Vehicle Service System. Handles
+             Handles user interactions such as login, customer registration, and role-based menu navigation
-             login, customer registration, and menu navigation for different
+             for Admin, Technician, and Customer modules.
-             user roles (Admin, Technician, Customer).
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
+
 #pragma once
 #include "Controller.h"
 #include "AdminMenu.h"