Commit aee6356e: Implement Confirm Payment Functionality

<User Story> Complete Payments - 1797</User Story>

<Changes>
1. Added Controller::getAllInvoices
   - Retrieves all invoices from PaymentManagementService and returns them as a read-only map.
2. Implemented Controller::confirmPayment
   - Delegates payment confirmation for a given invoice ID to PaymentManagementService.
3. Introduced PaymentManagementService::getAllInvoice
   - Provides access to all invoices stored in the datastore.
4. Added PaymentManagementService::confirmPayment
   - Confirms payment for a specific invoice, updates payment date and status, and sends notification.
5. Extended util::PaymentStatus enum
   - Added PAID status and updated string conversion.
6. Integrated AdminMenu::confirmPayment
   - Validates invoice list, filters by status, allows selection, and confirms payment.
7. Updated CustomerMenu::completePayments
   - Uses parameterized status filtering for invoice selection.
8. Enhanced MenuHelper::selectInvoiceFromUserForPayment
   - Accepts requiredStatus parameter for flexible filtering.
9. Adjusted AdminMenu options
   - Added "Confirm Payment" before Logout.
</Changes>

<Test>
Acceptance Criteria:
1. Admin selects "Confirm Payment" from menu.
   - Verify system prompts and displays invoices filtered by status.
2. Admin selects invoice with status = PAID.
   - Verify payment confirmation updates date, sets status, and sends notification.
3. Admin attempts confirmation with empty invoice list.
   - Verify error message: "No pending invoices available for confirmation."
4. Customer completes payment.
   - Verify selection uses util::PaymentStatus::PENDING and payment flow works correctly.
5. Invalid invoice ID entered.
   - Verify system throws runtime_error with "Payment failed: invalid invoice ID."

Precondition:
1. Admin logged into system.
2. At least one invoice exists in datastore.
3. Notification system available.

Steps:
1. Navigate to Admin menu → Confirm Payment.
2. Select invoice with PAID status.
3. Confirm payment and check notification.
4. Attempt with empty invoice list.
5. Attempt with invalid invoice ID.
</Test>

<Review>
Sreeja Reghukumar
</Review>

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

@@ -1,7 +1,24 @@
+/*
+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;
 	userInterface.run();
-}
+}

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

@@ -171,15 +171,21 @@
     <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\FileHelper.h" />
+    <ClInclude Include="utilities\FileManager.h" />
     <ClInclude Include="utilities\InputHelper.h" />
     <ClInclude Include="utilities\Map.h" />
     <ClInclude Include="utilities\OutputHelper.h" />
+    <ClInclude Include="utilities\StringHelper.h" />
     <ClInclude Include="utilities\Timestamp.h" />
+    <ClInclude Include="utilities\Utility.h" />
     <ClInclude Include="utilities\Validator.h" />
     <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,5 +233,23 @@
     <ClInclude Include="models\ComboPackage.h">
       <Filter>Header Files\Models</Filter>
     </ClInclude>
+    <ClInclude Include="utilities\Config.h">
+      <Filter>Header Files\Utilities</Filter>
+    </ClInclude>
+    <ClInclude Include="utilities\FileManager.h">
+      <Filter>Header Files\Utilities</Filter>
+    </ClInclude>
+    <ClInclude Include="utilities\StringHelper.h">
+      <Filter>Header Files\Utilities</Filter>
+    </ClInclude>
+    <ClInclude Include="utilities\FileHelper.h">
+      <Filter>Header Files\Utilities</Filter>
+    </ClInclude>
+    <ClInclude Include="utilities\Utility.h">
+      <Filter>Header Files\Utilities</Filter>
+    </ClInclude>
+    <ClInclude Include="views\MenuHelper.h">
+      <Filter>Header Files\Views</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

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

@@ -1,37 +1,113 @@
+/*
+File: Controller.cpp
+Description: Implementation file containing the method definitions of the
+             Controller class, including authentication, user creation,
+             service purchasing, and system checks.
+Author: Trenser
+Date:19-May-2026
+*/
+#include "ComboPackage.h"
 #include "Controller.h"
+#include "Enums.h"
 #include "InventoryItem.h"
+#include "Invoice.h"
+#include "JobCard.h"
 #include "Service.h"
 #include "ServiceBooking.h"
-#include "JobCard.h"
+#include "User.h"
+#include <stdexcept>
 
+/*
+Function: login
+Description: Authenticates a user by delegating to the authentication management service.
+Parameter: const std::string& username - user’s username
+           const std::string& password - user’s password
+Return type: bool - true if login successful, false otherwise
+*/
 bool Controller::login(const std::string& username, const std::string& password)
 {
-    return false;
+    return m_authenticationManagementService.login(username, password);
 }
 
+/*
+Function: logout
+Description: Logs out the currently authenticated user.
+Parameter: None
+Return type: void
+*/
 void Controller::logout()
 {
+    m_authenticationManagementService.logout();
 }
 
+/*
+Function: changePassword
+Description: Changes the password of the currently authenticated user.
+Parameter: const std::string& newPassword - new password to set
+Return type: void
+*/
 void Controller::changePassword(const std::string& newPassword)
 {
+    m_authenticationManagementService.changePassword(newPassword);
 }
 
-void Controller::createCustomer(const std::string& username, const std::string& password, const std::string& email, const std::string& phone)
+/*
+Function: createCustomer
+Description: Creates a new customer account with the provided details.
+Parameter: const std::string& username - customer’s username
+           const std::string& name - customer’s name
+           const std::string& password - customer’s password
+           const std::string& email - customer’s email
+           const std::string& phone - customer’s phone number
+Return type: void
+*/
+
+void Controller::createCustomer(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone)
 {
+    m_userManagementService.createUser(username, name, password, email, phone, util::UserType::CUSTOMER);
 }
 
+/*
+Function: getAuthenticatedUser
+Description: Retrieves the currently authenticated user.
+Parameter: None
+Return type: const User* - pointer to the authenticated user
+*/
 const User* Controller::getAuthenticatedUser()
 {
-    return nullptr;
+    return m_authenticationManagementService.getAuthenticatedUser();
 }
 
-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);
 }
 
+/*
+Function: updateUserDetails
+Description: Updates the email and phone details of the currently authenticated user.
+Parameter: const std::string& email - new email address
+           const std::string& phone - new phone number
+Return type: void
+*/
 void Controller::updateUserDetails(const std::string& email, const std::string& phone)
 {
+    User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
+    if (authenticatedUser == nullptr)
+    {
+        throw std::runtime_error("No user currently logged in!");
+    }
+    m_userManagementService.updateUserDetails(authenticatedUser->getId(), email, phone);
 }
 
 /*
@@ -53,36 +129,120 @@ util::Map<std::string, const Service*> Controller::getServices()
     return readOnlyServices;
 }
 
+/*
+Function: getComboPackages
+Description: Retrieves all available combo packages from the service
+             management service and constructs a read-only map.
+Parameter: None
+Return type: util::Map<std::string, const ComboPackage*>
+*/
 util::Map<std::string, const ComboPackage*> Controller::getComboPackages()
 {
-    return util::Map<std::string, const ComboPackage*>();
+    util::Map<std::string, ComboPackage*> currentAvailableComboPackages = m_serviceManagementService.getComboPackages();
+    util::Map<std::string, const ComboPackage*> readOnlyComboPackages;
+    for (int iterator = 0; iterator < currentAvailableComboPackages.getSize(); iterator++)
+    {
+        ComboPackage* currentComboPackage = currentAvailableComboPackages.getValueAt(iterator);
+        if (currentComboPackage)
+        {
+            readOnlyComboPackages.insert(currentComboPackage->getId(), currentComboPackage);
+        }
+    }
+    return readOnlyComboPackages;
 }
 
+/*
+Function: purchaseService
+Description: Purchases one or more services for a vehicle by delegating to the service management service.
+Parameter: const util::Vector<std::string>& serviceIDs - IDs of services to purchase
+           const std::string& vehicleNumber - vehicle registration number
+           const std::string& vehicleBrand - brand of the vehicle
+           const std::string& vehicleModel - model of the vehicle
+Return type: void
+*/
 void Controller::purchaseService(const util::Vector<std::string>& serviceIDs, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
 {
+    m_serviceManagementService.purchaseService(serviceIDs, vehicleNumber, vehicleBrand, vehicleModel);
 }
 
+/*
+Function: purchaseComboPackage
+Description: Purchases a combo package for a vehicle by delegating to the service management service.
+Parameter: const std::string& comboPackageID - ID of the combo package
+           const std::string& vehicleNumber - vehicle registration number
+           const std::string& vehicleBrand - brand of the vehicle
+           const std::string& vehicleModel - model of the vehicle
+Return type: void
+*/
 void Controller::purchaseComboPackage(const std::string& comboPackageID, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
 {
+    m_serviceManagementService.purchaseComboPackage(comboPackageID, vehicleNumber, vehicleBrand, vehicleModel);
 }
 
+/*
+Function: getInventoryItems
+Description: Retrieves all inventory items from the inventory management service
+             and constructs a read-only map for external use.
+Parameter: None
+Return type: util::Map<std::string, const InventoryItem*>
+*/
 util::Map<std::string, const InventoryItem*> Controller::getInventoryItems()
 {
-    util::Map<std::string, const InventoryItem*> dummyMap;
-    return dummyMap;
+    auto inventoryItems = m_inventoryManagementService.getInventoryItems();
+    util::Map<std::string, const InventoryItem*> readOnlyInventoryItems;
+    int inventoryItemsMapSize = inventoryItems.getSize();
+    for (int index = 0; index < inventoryItemsMapSize; index++)
+    {
+        readOnlyInventoryItems.insert(inventoryItems.getKeyAt(index), inventoryItems.getValueAt(index));
+    }
+    return readOnlyInventoryItems;
 }
 
+/*
+Function: getInventoryItem
+Description: Retrieves a specific inventory item by its ID from the inventory management service.
+Parameter: const std::string& inventoryItemID - ID of the inventory item
+Return type: const InventoryItem*
+*/
 const InventoryItem* Controller::getInventoryItem(const std::string& inventoryItemID)
 {
-    return nullptr;
+    return m_inventoryManagementService.getInventoryItem(inventoryItemID);
 }
 
+/*
+Function: addInventoryItem
+Description: Adds a new inventory item with specified details to the inventory management service.
+Parameter: const std::string& partName - name of the part
+           int quantity - quantity of the part
+           double price - price of the part
+Return type: void
+*/
 void Controller::addInventoryItem(const std::string& partName, int quantity, double price)
 {
+    m_inventoryManagementService.addInventoryItem(partName, quantity, price);
 }
 
+/*
+Function: removeInventoryItem
+Description: Removes an inventory item from the inventory management service by its ID.
+Parameter: const std::string& inventoryItemID - ID of the inventory item
+Return type: void
+*/
 void Controller::removeInventoryItem(const std::string& inventoryItemID)
 {
+    m_inventoryManagementService.removeInventoryItem(inventoryItemID);
+}
+
+/*
+Function: addInventoryItemStock
+Description: Adds stock to an existing inventory item in the inventory management service.
+Parameter: const std::string& selectedItemId - ID of the inventory item
+           int quantity - quantity to add
+Return type: void
+*/
+void Controller::addInventoryItemStock(const std::string& selectedItemId, int quantity)
+{
+    m_inventoryManagementService.addInventoryItemStock(selectedItemId, quantity);
 }
 
 /*
@@ -123,9 +283,22 @@ util::Map<std::string, const ServiceBooking*> Controller::getServiceBookingsByUs
     return readOnlyServiceBookingsByUserMap;
 }
 
+/*
+Function: getUsers
+Description: Retrieves all users from the user management service and
+             constructs a read-only map.
+Parameter: None
+Return type: util::Map<std::string, const User*>
+*/
 util::Map<std::string, const User*> Controller::getUsers()
 {
-    return util::Map<std::string, const User*>();
+    auto listOfUsers = m_userManagementService.getUsers();
+    util::Map<std::string, const User*> readOnlyUserList;
+    for (int iterator = 0; iterator < listOfUsers.getSize(); iterator++)
+    {
+        readOnlyUserList.insert(listOfUsers.getKeyAt(iterator), listOfUsers.getValueAt(iterator));
+    }
+    return readOnlyUserList;
 }
 
 /*
@@ -219,46 +392,258 @@ Parameters:
 Returns:
     - void
 */
-void Controller::completeJob(const std::string& jobID)
+void Controller::updateJobStatus(const std::string& jobID)
 {
-    m_serviceManagementService.completeJob(jobID);
+    m_serviceManagementService.updateJobStatus(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_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);
 }
 
+/*
+Function: getInvoicesByUser
+Description: Retrieves all invoices associated with the currently authenticated user.
+             Converts them into a read-only map before returning.
+Parameters:
+    - None
+Returns:
+    - util::Map<std::string, const Invoice*> containing the user’s invoices
+*/
 util::Map<std::string, const Invoice*> Controller::getInvoicesByUser()
 {
-    return util::Map<std::string, const Invoice*>();
+    User* currentUser = m_authenticationManagementService.getAuthenticatedUser();
+    util::Map<std::string, Invoice*> currentUserInvoices =  m_paymentManagementService.getInvoices(currentUser->getId());
+    util::Map<std::string, const Invoice*> userInvoicesReadOnly;
+    for (int iterator = 0; iterator < currentUserInvoices.getSize(); iterator++)
+    {
+        Invoice* currentInvoice = currentUserInvoices.getValueAt(iterator);
+        userInvoicesReadOnly.insert(currentInvoice->getId(), currentInvoice);
+    }
+    return userInvoicesReadOnly;
 }
 
+/*
+Function: getAllInvoices
+Description: Retrieves all invoices from the PaymentManagementService and returns them as a read-only map.
+Parameters:
+    - none
+Returns:
+    - util::Map<std::string, const Invoice*>: Map of invoice IDs to invoice objects
+*/
+util::Map<std::string, const Invoice*> Controller::getAllInvoices()
+{
+    auto invoices = m_paymentManagementService.getAllInvoices();
+    util::Map<std::string, const Invoice*> readOnlyInvoice;
+    for (int iterator = 0; iterator < invoices.getSize(); iterator++)
+    {
+        readOnlyInvoice.insert(invoices.getKeyAt(iterator), invoices.getValueAt(iterator));
+    }
+    return readOnlyInvoice;
+}
+
+/*
+Function: confirmPayment
+Description: Delegates payment confirmation for a given invoice ID to the PaymentManagementService.
+Parameters:
+    - invoiceID: std::string, ID of the invoice to confirm
+Returns:
+    - void
+*/
+void Controller::confirmPayment(const std::string& invoiceID)
+{
+    m_paymentManagementService.confirmPayment(invoiceID);
+}
+
+/*
+Function: completePayment
+Description: Completes payment for a specific invoice using the given payment mode.
+Parameters:
+    - invoiceID: std::string, ID of the invoice to be paid
+    - paymentMode: util::PaymentMode, mode of payment (e.g., ONLINE, OFFLINE)
+Returns:
+    - void
+*/
 void Controller::completePayment(const std::string& invoiceID, util::PaymentMode paymentMode)
 {
+    m_paymentManagementService.completePayment(invoiceID, paymentMode);
 }
 
+/*
+Function: getNotifications
+Description: Retrieves all notifications for the currently authenticated user.
+             Converts them into a read-only vector before returning.
+Parameters: None
+Return type: util::Vector<const Notification*>
+*/
 util::Vector<const Notification*> Controller::getNotifications()
 {
-    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: loadSystemData
+Description: Loads all system data from persistent storage into memory.
+             Invokes the respective management services to load users, inventory items, services,
+             combo packages, service bookings, job cards, invoices, and observers.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void Controller::loadSystemData()
+{
+    m_userManagementService.loadUsers();
+    m_inventoryManagementService.loadInventoryItems();
+    m_serviceManagementService.loadServices();
+    m_serviceManagementService.loadComboPackages();
+    m_serviceManagementService.loadServiceBookings();
+    m_serviceManagementService.loadJobCards();
+    m_paymentManagementService.loadInvoices();
+    m_serviceManagementService.loadObservers();
+    m_paymentManagementService.loadObservers();
+    m_inventoryManagementService.loadObservers();
+}
+
+/*
+Function: saveSystemData
+Description: Saves all system data from memory back to persistent storage.
+             Invokes the respective management services to save users, inventory items, services,
+             combo packages, service bookings, job cards, invoices, and observers.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void Controller::saveSystemData()
+{
+    m_userManagementService.saveUsers();
+    m_inventoryManagementService.saveInventoryItems();
+    m_serviceManagementService.saveServices();
+    m_serviceManagementService.saveComboPackages();
+    m_serviceManagementService.saveServiceBookings();
+    m_serviceManagementService.saveJobCards();
+    m_paymentManagementService.saveInvoices();
+    m_serviceManagementService.saveObservers();
+    m_paymentManagementService.saveObservers();
+    m_inventoryManagementService.saveObservers();
+}
+
+/*
+Function: runSystemChecks
+Description: Runs system checks to ensure critical configurations, such as verifying admin existence.
+Parameter: None
+Return type: void
+*/
 void Controller::runSystemChecks()
 {
+    m_userManagementService.ensureAdminExists();
+    m_inventoryManagementService.sendLowStockAlerts();
+    m_paymentManagementService.sendPaymentReminders();
 }
 

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

@@ -1,10 +1,21 @@
+/*
+File: Controller.h
+Description: Header file declaring the Controller class, which manages
+             user authentication, inventory, services, bookings, job cards,
+             invoices, and notifications in the system.
+Author: Trenser
+Date:19-May-2026
+*/
+
 #pragma once
-#include "Map.h"
 #include <string>
+#include "AuthenticationManagementService.h"
 #include "Enums.h"
+#include "InventoryManagementService.h"
+#include "Map.h"
+#include "PaymentManagementService.h"
 #include "ServiceManagementService.h"
 #include "UserManagementService.h"
-#include "InventoryManagementService.h"
 
 class Service;
 class ComboPackage;
@@ -18,15 +29,18 @@ class Notification;
 class Controller
 {
 private:
-    ServiceManagementService m_serviceManagementService;
+    AuthenticationManagementService  m_authenticationManagementService;
     UserManagementService m_userManagementService;
+    ServiceManagementService m_serviceManagementService;    
+    InventoryManagementService m_inventoryManagementService;
+    PaymentManagementService m_paymentManagementService;
 public:
     bool login(const std::string& username, const std::string& password);
     void logout();
     void changePassword(const std::string& newPassword);
-    void createCustomer(const std::string& username, const std::string& password, const std::string& email, const std::string& phone);
+    void createCustomer(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone);
     const User* getAuthenticatedUser();
-    void createTechnician(const std::string& username, const std::string& password, const std::string& email, const std::string& phone);
+    void createTechnician(const std::string& username, const std::string& name, 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();
@@ -35,6 +49,7 @@ public:
     util::Map<std::string, const InventoryItem*> getInventoryItems();
     const InventoryItem* getInventoryItem(const std::string& inventoryItemID);
     void addInventoryItem(const std::string& partName, int quantity, double price);
+    void addInventoryItemStock(const std::string& selectedItemId, int quantity);
     void removeInventoryItem(const std::string& inventoryItemID);
     util::Map<std::string, const ServiceBooking*> getServiceBookings();
     util::Map<std::string, const ServiceBooking*> getServiceBookingsByUser(const std::string userID);
@@ -44,14 +59,18 @@ public:
     void createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost);
     void removeService(const std::string& serviceID);
     util::Map<std::string, const JobCard*> getJobCardsByUser();
-    void completeJob(const std::string& jobID);
+    void updateJobStatus(const std::string& jobID);
     void removeUser(const std::string& userID);
     void createComboPackage(const std::string& name, const util::Vector<std::string>& serviceIDs, double discountPercentage);
     void removeComboPackage(const std::string& comboPackageID);
     util::Map<std::string, const Invoice*> getInvoicesByUser();
+    util::Map<std::string, const Invoice*> getAllInvoices();
+    void confirmPayment(const std::string& invoiceID);
     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 loadSystemData();
+    void saveSystemData();
     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,6 +1,14 @@
+/*
+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"
+#include "Vector.h"
 
 class User;
 class Notification;

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,65 +1,341 @@
+/*
+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 <sstream>
+#include <stdexcept>
 #include "ComboPackage.h"
+#include "Service.h"
+#include "Factory.h"
+#include "StringHelper.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),
     m_discountPercentage(discountPercentage),
     m_status(util::State::ACTIVE),
-    m_services(services) {}
+    m_services(services)
+{
+    int numberOfServices = m_services.getSize();
+    auto servicePointers = m_services.getValues();
+    for (int index = 0; index < numberOfServices; index++)
+    {
+        m_serviceIDs.push_back(servicePointers[index]->getId());
+    }
+}
 
+/*
+Function: ComboPackage (parameterized constructor with ID)
+Description: Initializes a combo package with an existing ID, name, discount percentage,
+             service IDs, and state. Updates UID tracking based on ID.
+Parameters:
+    - id: const std::string&, unique ID of the package
+    - packageName: const std::string&, name of the package
+    - discountPercentage: double, discount percentage applied
+    - serviceIDs: const util::Vector<std::string>&, IDs of services included
+    - status: util::State, state of the package (ACTIVE/INACTIVE)
+Returns:
+    - A new ComboPackage object
+*/
+ComboPackage::ComboPackage(const std::string& id, const std::string& packageName, double discountPercentage, const util::Vector<std::string>& serviceIDs, util::State status)
+    : m_id(id),
+    m_packageName(packageName),
+    m_discountPercentage(discountPercentage),
+    m_serviceIDs(serviceIDs),
+    m_status(status)
+{
+    int idNumber = util::extractNumber(m_id);
+    if (idNumber > m_uid)
+    {
+        m_uid = idNumber;
+    }
+}
+
+/*
+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;
 }
 
+const util::Vector<std::string>& ComboPackage::getServiceIDs() const
+{
+    return m_serviceIDs;
+}
+
+/*
+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;
+    m_serviceIDs.clear();
+    int numberOfServices = m_services.getSize();
+    auto servicePointers = m_services.getValues();
+    for (int index = 0; index < numberOfServices; index++)
+    {
+        m_serviceIDs.push_back(servicePointers[index]->getId());
+    }
 }
 
+/*
+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;
 }
+
+/*
+Function: getServiceIDsAsString (static helper)
+Description: Converts a vector of service IDs into a single string separated by '|'.
+Parameters:
+    - serviceIDs: const util::Vector<std::string>&, vector of service IDs
+Returns:
+    - std::string: Concatenated service IDs string
+*/
+static std::string getServiceIDsAsString(const util::Vector<std::string>& serviceIDs)
+{
+    int numberOfServices = serviceIDs.getSize();
+    std::string serviceIDsString;
+    for (int index = 0; index < numberOfServices; index++)
+    {
+        serviceIDsString += serviceIDs[index];
+        if (index < numberOfServices - 1)
+        {
+            serviceIDsString += '|';
+        }
+    }
+    return serviceIDsString;
+}
+
+/*
+Function: getServiceIDsAsVector (static helper)
+Description: Converts a string of service IDs separated by '|' into a vector.
+Parameters:
+    - serviceIDsString: const std::string&, concatenated service IDs string
+Returns:
+    - util::Vector<std::string>: Vector of service IDs
+*/
+static util::Vector<std::string> getServiceIDsAsVector(const std::string& serviceIDsString)
+{
+    util::Vector<std::string> serviceIDs;
+    std::string serviceID;
+    std::istringstream serializedServiceIDs(serviceIDsString);
+    while (getline(serializedServiceIDs, serviceID, '|'))
+    {
+        serviceIDs.push_back(serviceID);
+    }
+    return serviceIDs;
+}
+
+/*
+Function: serialize
+Description: Serializes the combo package into a CSV-formatted string.
+Parameters:
+    - None
+Returns:
+    - std::string: Serialized combo package record
+*/
+std::string ComboPackage::serialize() const
+{
+    std::ostringstream serializedComboPackage;
+    serializedComboPackage << m_id << ','
+        << m_packageName << ','
+        << m_discountPercentage << ','
+        << getServiceIDsAsString(m_serviceIDs) << ','
+        << util::getStateString(m_status);
+    return serializedComboPackage.str();
+}
+
+/*
+Function: deserialize
+Description: Deserializes a CSV-formatted string into a ComboPackage object.
+Parameters:
+    - record: const std::string&, serialized combo package record
+Returns:
+    - ComboPackage*: Pointer to the deserialized ComboPackage object
+Throws:
+    - std::runtime_error if data is invalid
+*/
+ComboPackage* ComboPackage::deserialize(const std::string& record)
+{
+    std::string id, packageName;
+    std::string discountPercentageString, serviceIDsString, statusString;
+    double discountPercentage;
+    std::istringstream serializedComboPackage(record);
+    getline(serializedComboPackage, id, ',');
+    getline(serializedComboPackage, packageName, ',');
+    getline(serializedComboPackage, discountPercentageString, ',');
+    getline(serializedComboPackage, serviceIDsString, ',');
+    getline(serializedComboPackage, statusString, ',');
+    try
+    {
+        discountPercentage = std::stod(discountPercentageString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid combo package data");
+    }
+    util::Vector<std::string> serviceIDs = getServiceIDsAsVector(serviceIDsString);
+    util::State status = util::getState(statusString);
+    return Factory::getObject<ComboPackage>(
+        id,
+        packageName,
+        discountPercentage,
+        serviceIDs,
+        status
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for combo package serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,PackageName,DiscountPercentage,ServiceIDs,Status")
+*/
+std::string ComboPackage::getHeaders()
+{
+    return "ID,PackageName,DiscountPercentage,ServiceIDs,Status";
+}

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

@@ -1,6 +1,14 @@
+/*
+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"
+#include "Vector.h"
 #include "Enums.h"
 
 class Service;
@@ -12,14 +20,17 @@ private:
     std::string m_id;
     std::string m_packageName;
     double m_discountPercentage;
+    util::Vector<std::string> m_serviceIDs;
     util::Map<std::string, Service*> m_services;
     util::State m_status;
 public:
     ComboPackage();
     ComboPackage(const std::string& packageName, double discountPercentage, const util::Map<std::string, Service*>& services);
+    ComboPackage(const std::string& id, const std::string& packageName, double discountPercentage, const util::Vector<std::string>& serviceIDs, util::State status);
     const std::string& getId() const;
     const std::string& getPackageName() const;
     double getDiscountPercentage() const;
+    const util::Vector<std::string>& getServiceIDs() const;
     const util::Map<std::string, Service*>& getServices() const;
     util::State getState() const;
     void setId(const std::string& id);
@@ -27,4 +38,7 @@ public:
     void setDiscountPercentage(double discountPercentage);
     void setServices(const util::Map<std::string, Service*>& services);
     void setState(util::State status);
+    std::string serialize() const;
+    static ComboPackage* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

@@ -1,13 +1,45 @@
+/*
+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 <sstream>
+#include <stdexcept>
+#include "Factory.h"
+#include "StringHelper.h"
 #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,52 +47,232 @@ InventoryItem::InventoryItem(const std::string& partName, int quantity, double p
     m_status(util::State::ACTIVE),
     m_price(price) {}
 
+/*
+Function: InventoryItem (parameterized constructor with ID)
+Description: Initializes an inventory item with an existing ID, part name, quantity,
+             price, and state. Updates UID tracking based on ID.
+Parameters:
+    - id: const std::string&, unique ID of the item
+    - partName: const std::string&, name of the part
+    - quantity: int, quantity of the part
+    - price: double, price of the part
+    - status: util::State, state of the item (ACTIVE/INACTIVE)
+Returns:
+    - A new InventoryItem object
+*/
+InventoryItem::InventoryItem(const std::string& id, const std::string& partName, int quantity, double price, util::State status)
+    : m_id(id),
+    m_partName(partName),
+    m_quantity(quantity),
+    m_status(status),
+    m_price(price)
+{
+    int idNumber = util::extractNumber(m_id);
+    if (idNumber > m_uid)
+    {
+        m_uid = idNumber;
+    }
+}
+
+/*
+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;
+}
+
+/*
+Function: serialize
+Description: Serializes the inventory item into a CSV-formatted string.
+Parameters:
+    - None
+Returns:
+    - std::string: Serialized inventory item record
+*/
+std::string InventoryItem::serialize() const
+{
+    std::ostringstream serializedInventoryItem;
+    serializedInventoryItem << m_id << ','
+        << m_partName << ','
+        << m_quantity << ','
+        << m_price << ','
+        << util::getStateString(m_status);
+    return serializedInventoryItem.str();
+}
+
+/*
+Function: deserialize
+Description: Deserializes a CSV-formatted string into an InventoryItem object.
+Parameters:
+    - record: const std::string&, serialized inventory item record
+Returns:
+    - InventoryItem*: Pointer to the deserialized InventoryItem object
+Throws:
+    - std::runtime_error if data is invalid
+*/
+InventoryItem* InventoryItem::deserialize(const std::string& record)
+{
+    std::string id, partName;
+    std::string quantityString, priceString, statusString;
+    int quantity;
+    double price;
+    std::istringstream serializedInventoryItem(record);
+    getline(serializedInventoryItem, id, ',');
+    getline(serializedInventoryItem, partName, ',');
+    getline(serializedInventoryItem, quantityString, ',');
+    getline(serializedInventoryItem, priceString, ',');
+    getline(serializedInventoryItem, statusString, ',');
+    try
+    {
+        quantity = std::stoi(quantityString);
+        price = std::stod(priceString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid inventory item data");
+    }
+    util::State status = util::getState(statusString);
+    return Factory::getObject<InventoryItem>(
+        id,
+        partName,
+        quantity,
+        price,
+        status
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for inventory item serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,PartName,Quantity,Price,Status")
+*/
+std::string InventoryItem::getHeaders()
+{
+    return "ID,PartName,Quantity,Price,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"
@@ -14,6 +23,7 @@ private:
 public:
     InventoryItem();
     InventoryItem(const std::string& partName, int quantity, double price);
+    InventoryItem(const std::string& id, const std::string& partName, int quantity, double price, util::State status);
     const std::string& getId() const;
     const std::string& getPartName() const;
     int getQuantity() const;
@@ -24,4 +34,7 @@ public:
     void setQuantity(int quantity);
     void setPrice(double price);
     void setState(util::State status);
+    std::string serialize() const;
+    static InventoryItem* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

@@ -1,7 +1,31 @@
+/*
+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 <sstream>
+#include <stdexcept>
 #include "Invoice.h"
+#include "Factory.h"
+#include "InventoryItem.h"
+#include "StringHelper.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,12 +36,30 @@ 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,
     const util::Timestamp& invoiceDate, 
-    double laborCost, const util::Map<int,
-    InventoryItem*>& parts,
+    double laborCost, 
+    const util::Map<std::string, InventoryItem*>& parts,
     double partsCost,
     double discountPercentage, 
     double totalAmount, 
@@ -36,124 +78,495 @@ Invoice::Invoice(
     m_totalAmount(totalAmount),
     m_paymentDate(paymentDate),
     m_paymentMethod(paymentMethod),
-    m_status(status) {}
+    m_status(status) 
+{
+    int numberOfParts = m_parts.getSize();
+    auto partPointers = m_parts.getValues();
+    for (int index = 0; index < numberOfParts; index++)
+    {
+        m_partIDs.push_back(partPointers[index]->getId());
+    }
+}
+Invoice::Invoice(
+    const std::string& id,
+    const std::string& bookingId,
+    const util::Timestamp& invoiceDate,
+    const util::Vector<std::string>& partIDs,
+    double laborCost,
+    double partsCost,
+    double discountPercentage,
+    double totalAmount,
+    const util::Timestamp& paymentDate,
+    util::PaymentMode paymentMethod,
+    util::PaymentStatus status
+)
+    : m_id(id),
+    m_bookingId(bookingId),
+    m_booking(nullptr),
+    m_invoiceDate(invoiceDate),
+    m_partIDs(partIDs),
+    m_laborCost(laborCost),
+    m_partsCost(partsCost),
+    m_discountPercentage(discountPercentage),
+    m_totalAmount(totalAmount),
+    m_paymentDate(paymentDate),
+    m_paymentMethod(paymentMethod),
+    m_status(status)
+{
+    int idNumber = util::extractNumber(m_id);
+    if (idNumber > m_uid)
+    {
+        m_uid = idNumber;
+    }
+}
 
+/*
+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;
 }
 
-const util::Map<int, InventoryItem*>& Invoice::getParts() const
+/*
+Function: getPartIDs
+Description: Retrieves the IDs of parts used in the invoice.
+Parameters:
+    - None
+Returns:
+    - const util::Vector<std::string>&: Part IDs
+*/
+const util::Vector<std::string>& Invoice::getPartIDs() const
+{
+    return m_partIDs;
+}
+
+/*
+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<std::string, 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;
 }
 
-void Invoice::setParts(const util::Map<int, InventoryItem*>& parts)
+/*
+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<std::string, InventoryItem*>& parts)
 {
     m_parts = parts;
+    m_partIDs.clear();
+    int numberOfParts = m_parts.getSize();
+    auto partPointers = m_parts.getValues();
+    for (int index = 0; index < numberOfParts; index++)
+    {
+        m_partIDs.push_back(partPointers[index]->getId());
+    }
 }
 
+/*
+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;
 }
+
+/*
+Function: getPartIDsAsString (static helper)
+Description: Converts a vector of part IDs into a single string separated by '|'.
+Parameters:
+    - partIDs: const util::Vector<std::string>&, vector of part IDs
+Returns:
+    - std::string: Concatenated part IDs string
+*/
+static std::string getPartIDsAsString(const util::Vector<std::string>& partIDs)
+{
+    int numberOfParts = partIDs.getSize();
+    std::string partIDsString;
+    for (int index = 0; index < numberOfParts; index++)
+    {
+        partIDsString += partIDs[index];
+        if (index < numberOfParts - 1)
+        {
+            partIDsString += '|';
+        }
+    }
+    return partIDsString;
+}
+
+/*
+Function: getPartIDsAsVector (static helper)
+Description: Converts a string of part IDs separated by '|' into a vector.
+Parameters:
+    - partIDsString: const std::string&, concatenated part IDs string
+Returns:
+    - util::Vector<std::string>: Vector of part IDs
+*/
+static util::Vector<std::string> getPartIDsAsVector(const std::string& partIDsString)
+{
+    util::Vector<std::string> partIDs;
+    std::string partID;
+    std::istringstream serializedPartIDs(partIDsString);
+    while (getline(serializedPartIDs, partID, '|'))
+    {
+        partIDs.push_back(partID);
+    }
+    return partIDs;
+}
+
+/*
+Function: serialize
+Description: Serializes the invoice into a CSV-formatted string.
+Parameters:
+    - None
+Returns:
+    - std::string: Serialized invoice record
+*/
+std::string Invoice::serialize() const
+{
+    std::ostringstream serializedInvoice;
+    serializedInvoice << m_id << ','
+        << m_bookingId << ','
+        << m_invoiceDate.toString() << ','
+        << m_laborCost << ','
+        << getPartIDsAsString(m_partIDs) << ','
+        << m_partsCost << ','
+        << m_discountPercentage << ','
+        << m_totalAmount << ','
+        << m_paymentDate.toString() << ','
+        << util::getPaymentModeString(m_paymentMethod) << ','
+        << util::getPaymentStatusString(m_status);
+    return serializedInvoice.str();
+}
+
+/*
+Function: deserialize
+Description: Deserializes a CSV-formatted string into an Invoice object.
+Parameters:
+    - record: const std::string&, serialized invoice record
+Returns:
+    - Invoice*: Pointer to the deserialized Invoice object
+Throws:
+    - std::runtime_error if data is invalid
+*/
+Invoice* Invoice::deserialize(const std::string& record)
+{
+    std::string id, bookingId;
+    std::string invoiceDateString, laborCostString, partIDsString;
+    std::string partsCostString, discountPercentageString, totalAmountString;
+    std::string paymentDateString, paymentMethodString, statusString;
+    double laborCost, partsCost, discountPercentage, totalAmount;
+    std::istringstream serializedInvoice(record);
+    getline(serializedInvoice, id, ',');
+    getline(serializedInvoice, bookingId, ',');
+    getline(serializedInvoice, invoiceDateString, ',');
+    getline(serializedInvoice, laborCostString, ',');
+    getline(serializedInvoice, partIDsString, ',');
+    getline(serializedInvoice, partsCostString, ',');
+    getline(serializedInvoice, discountPercentageString, ',');
+    getline(serializedInvoice, totalAmountString, ',');
+    getline(serializedInvoice, paymentDateString, ',');
+    getline(serializedInvoice, paymentMethodString, ',');
+    getline(serializedInvoice, statusString, ',');
+    util::Timestamp invoiceDate;
+    util::Timestamp paymentDate;
+    try
+    {
+        invoiceDate = util::Timestamp::fromString(invoiceDateString);
+        paymentDate = util::Timestamp::fromString(paymentDateString);
+        laborCost = std::stod(laborCostString);
+        partsCost = std::stod(partsCostString);
+        discountPercentage = std::stod(discountPercentageString);
+        totalAmount = std::stod(totalAmountString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid invoice data");
+    }
+    util::Vector<std::string> partIDs = getPartIDsAsVector(partIDsString);
+    util::PaymentMode paymentMethod = util::getPaymentMode(paymentMethodString);
+    util::PaymentStatus status = util::getPaymentStatus(statusString);
+    return Factory::getObject<Invoice>(
+        id,
+        bookingId,
+        invoiceDate,
+        partIDs,
+        laborCost,
+        partsCost,
+        discountPercentage,
+        totalAmount,
+        paymentDate,
+        paymentMethod,
+        status
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for invoice serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,BookingID,InvoiceDate,LaborCost,PartIDs,PartsCost,DiscountPercentage,TotalAmount,PaymentDate,PaymentMethod,Status")
+*/
+std::string Invoice::getHeaders()
+{
+    return "ID,BookingID,InvoiceDate,LaborCost,PartIDs,PartsCost,DiscountPercentage,TotalAmount,PaymentDate,PaymentMethod,Status";
+}

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

@@ -1,6 +1,16 @@
+/*
+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"
+#include "Vector.h"
 #include "Timestamp.h"
 #include "Enums.h"
 
@@ -16,22 +26,22 @@ private:
     ServiceBooking* m_booking;
     util::Timestamp m_invoiceDate;
     double m_laborCost;
-    util::Map<int, InventoryItem*> m_parts;
+    util::Vector<std::string> m_partIDs;
+    util::Map<std::string, InventoryItem*> m_parts;
     double m_partsCost;
     double m_discountPercentage;
     double m_totalAmount;
     util::Timestamp m_paymentDate;
     util::PaymentMode m_paymentMethod;
     util::PaymentStatus m_status;
-
 public:
     Invoice();
     Invoice(
         const std::string& bookingId,
         ServiceBooking* booking,
         const util::Timestamp& invoiceDate, 
-        double laborCost, const util::Map<int,
-        InventoryItem*>& parts,
+        double laborCost, 
+        const util::Map<std::string,InventoryItem*>& parts,
         double partsCost,
         double discountPercentage, 
         double totalAmount, 
@@ -39,12 +49,26 @@ public:
         util::PaymentMode paymentMethod, 
         util::PaymentStatus status
     );
+    Invoice(
+        const std::string& id,
+        const std::string& bookingId,
+        const util::Timestamp& invoiceDate,
+        const util::Vector<std::string>& partIDs,
+        double laborCost,
+        double partsCost,
+        double discountPercentage,
+        double totalAmount,
+        const util::Timestamp& paymentDate,
+        util::PaymentMode paymentMethod,
+        util::PaymentStatus status
+    );
     const std::string& getId() const;
     const std::string& getBookingId() const;
     ServiceBooking* getBooking() const;
     const util::Timestamp& getInvoiceDate() const;
     double getLaborCost() const;
-    const util::Map<int, InventoryItem*>& getParts() const;
+    const util::Vector<std::string>& getPartIDs() const;
+    const util::Map<std::string, InventoryItem*>& getParts() const;
     double getPartsCost() const;
     double getDiscountPercentage() const;
     double getTotalAmount() const;
@@ -56,11 +80,14 @@ public:
     void setBooking(ServiceBooking* booking);
     void setInvoiceDate(const util::Timestamp& invoiceDate);
     void setLaborCost(double laborCost);
-    void setParts(const util::Map<int, InventoryItem*>& parts);
+    void setParts(const util::Map<std::string, InventoryItem*>& parts);
     void setPartsCost(double partsCost);
     void setDiscountPercentage(double discountPercentage);
     void setTotalAmount(double totalAmount);
     void setPaymentDate(const util::Timestamp& paymentDate);
     void setPaymentMethod(util::PaymentMode paymentMethod);
     void setStatus(util::PaymentStatus status);
+    std::string serialize() const;
+    static Invoice* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

@@ -1,7 +1,28 @@
+/*
+File: JobCard.cpp
+Description: Implementation file containing the method definitions of the
+             JobCard class, including constructors, getters, and setters
+             for job card attributes.
+Author: Trenser
+Date:19-May-2026
+*/
+
+#include <sstream>
+#include <stdexcept>
 #include "JobCard.h"
+#include "Factory.h"
+#include "StringHelper.h"
+#include "Enums.h"
 
 int JobCard::m_uid = 0;
 
+/*
+Function: JobCard
+Description: Default constructor that initializes a new job card with
+             a unique ID and default values.
+Parameter: None
+Return type: Constructor
+*/
 JobCard::JobCard()
     : m_id("JC" + std::to_string(++m_uid)),
     m_booking(nullptr),
@@ -9,6 +30,22 @@ JobCard::JobCard()
     m_technician(nullptr),
     m_status(util::ServiceJobStatus()) {}
 
+/*
+Function: JobCard
+Description: Parameterized constructor that initializes a new job card with a unique ID and specified details.
+Parameters:
+    - bookingId: ID of the associated service booking.
+    - booking: Pointer to the ServiceBooking object.
+    - service: Pointer to the Service object.
+    - serviceId: ID of the associated service.
+    - technicianId: ID of the assigned technician.
+    - technician: Pointer to the User object representing the technician.
+    - assignedDate: Timestamp of when the job was assigned.
+    - status: Current status of the job (STARTED/COMPLETED).
+    - completionDate: Timestamp of when the job was completed.
+Returns:
+    - A new JobCard object.
+*/
 JobCard::JobCard(const std::string& bookingId,
     ServiceBooking* booking,
     Service* service,
@@ -30,102 +67,363 @@ JobCard::JobCard(const std::string& bookingId,
     m_status(status),
     m_completionDate(completionDate) {}
 
+/*
+Function: JobCard (parameterized constructor with ID)
+Description: Initializes a job card with an existing ID, booking ID, service ID,
+             technician ID, assignment date, completion date, and status.
+             Updates UID tracking based on ID.
+Parameters:
+    - id: const std::string&, unique job card ID
+    - bookingId: const std::string&, ID of the booking
+    - serviceId: const std::string&, ID of the service
+    - technicianId: const std::string&, ID of the technician
+    - assignedDate: const util::Timestamp&, date of assignment
+    - status: util::ServiceJobStatus, job status
+    - completionDate: const util::Timestamp&, date of completion
+Returns:
+    - A new JobCard object
+*/
+JobCard::JobCard(const std::string& id,
+    const std::string& bookingId,
+    const std::string& serviceId,
+    const std::string& technicianId,
+    const util::Timestamp& assignedDate,
+    util::ServiceJobStatus status,
+    const util::Timestamp& completionDate
+)
+    : m_id(id),
+    m_bookingId(bookingId),
+    m_booking(nullptr),
+    m_service(nullptr),
+    m_serviceId(serviceId),
+    m_technicianId(technicianId),
+    m_technician(nullptr),
+    m_assignedDate(assignedDate),
+    m_status(status),
+    m_completionDate(completionDate)
+{
+    int idNumber = util::extractNumber(m_id);
+    if (idNumber > m_uid)
+    {
+        m_uid = idNumber;
+    }
+}
+
+/*
+Function: getId
+Description: Retrieves the unique ID of the job card.
+Returns:
+    - const std::string& representing the job card ID.
+*/
 const std::string& JobCard::getId() const
 {
     return m_id;
 }
 
+/*
+Function: getBookingId
+Description: Retrieves the booking ID associated with the job card.
+Returns:
+    - const std::string& representing the booking ID.
+*/
 const std::string& JobCard::getBookingId() const
 {
     return m_bookingId;
 }
 
+/*
+Function: getBooking
+Description: Retrieves the pointer to the associated ServiceBooking.
+Returns:
+    - ServiceBooking* representing the booking.
+*/
 ServiceBooking* JobCard::getBooking() const
 {
     return m_booking;
 }
 
+/*
+Function: getService
+Description: Retrieves the pointer to the associated Service.
+Returns:
+    - Service* representing the service.
+*/
 Service* JobCard::getService() const
 {
     return m_service;
 }
 
+/*
+Function: getServiceId
+Description: Retrieves the service ID associated with the job card.
+Returns:
+    - const std::string& representing the service ID.
+*/
 const std::string& JobCard::getServiceId() const
 {
     return m_serviceId;
 }
 
+/*
+Function: getTechnicianId
+Description: Retrieves the technician ID associated with the job card.
+Returns:
+    - const std::string& representing the technician ID.
+*/
 const std::string& JobCard::getTechnicianId() const
 {
     return m_technicianId;
 }
 
+/*
+Function: getTechnician
+Description: Retrieves the pointer to the assigned technician.
+Returns:
+    - User* representing the technician.
+*/
 User* JobCard::getTechnician() const
 {
     return m_technician;
 }
 
+/*
+Function: getAssignedDate
+Description: Retrieves the timestamp of when the job was assigned.
+Returns:
+    - const util::Timestamp& representing the assigned date.
+*/
 const util::Timestamp& JobCard::getAssignedDate() const
 {
     return m_assignedDate;
 }
 
+/*
+Function: getStatus
+Description: Retrieves the current status of the job.
+Returns:
+    - ServiceJobStatus representing the job status.
+*/
 util::ServiceJobStatus JobCard::getStatus() const
 {
     return m_status;
 }
 
+/*
+Function: getCompletionDate
+Description: Retrieves the timestamp of when the job was completed.
+Returns:
+    - const util::Timestamp& representing the completion date.
+*/
 const util::Timestamp& JobCard::getCompletionDate() const
 {
     return m_completionDate;
 }
 
+/*
+Function: setId
+Description: Sets the unique ID of the job card.
+Parameters:
+    - id: New job card ID string.
+Returns:
+    - void
+*/
 void JobCard::setId(const std::string& id)
 {
     m_id = id;
 }
 
+/*
+Function: setBookingId
+Description: Sets the booking ID associated with the job card.
+Parameters:
+    - bookingId: New booking ID string.
+Returns:
+    - void
+*/
 void JobCard::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 JobCard::setBooking(ServiceBooking* booking)
 {
     m_booking = booking;
 }
 
+/*
+Function: setService
+Description: Sets the associated Service pointer.
+Parameters:
+    - service: Pointer to the Service object.
+Returns:
+    - void
+*/
 void JobCard::setService(Service* service)
 {
     m_service = service;
 }
 
+/*
+Function: setServiceId
+Description: Sets the service ID associated with the job card.
+Parameters:
+    - serviceId: New service ID string.
+Returns:
+    - void
+*/
 void JobCard::setServiceId(const std::string& serviceId)
 {
     m_serviceId = serviceId;
 }
 
+/*
+Function: setTechnicianId
+Description: Sets the technician ID associated with the job card.
+Parameters:
+    - technicianId: New technician ID string.
+Returns:
+    - void
+*/
 void JobCard::setTechnicianId(const std::string& technicianId)
 {
     m_technicianId = technicianId;
 }
 
+/*
+Function: setTechnician
+Description: Sets the pointer to the assigned technician.
+Parameters:
+    - technician: Pointer to the User object.
+Returns:
+    - void
+*/
 void JobCard::setTechnician(User* technician)
 {
     m_technician = technician;
 }
 
+/*
+Function: setAssignedDate
+Description: Sets the timestamp of when the job was assigned.
+Parameters:
+    - assignedDate: New timestamp for the assigned date.
+Returns:
+    - void
+*/
 void JobCard::setAssignedDate(const util::Timestamp& assignedDate)
 {
     m_assignedDate = assignedDate;
 }
 
+/*
+Function: setStatus
+Description: Sets the current status of the job.
+Parameters:
+    - status: New job status value.
+Returns:
+    - void
+*/
 void JobCard::setStatus(util::ServiceJobStatus status)
 {
     m_status = status;
 }
 
+/*
+Function: setCompletionDate
+Description: Sets the timestamp of when the job was completed.
+Parameters:
+    - completionDate: New timestamp for the completion date.
+Returns:
+    - void
+*/
 void JobCard::setCompletionDate(const util::Timestamp& completionDate)
 {
     m_completionDate = completionDate;
+}
+
+/*
+Function: serialize
+Description: Serializes the job card into a CSV-formatted string.
+Parameters:
+    - None
+Returns:
+    - std::string: Serialized job card record
+*/
+std::string JobCard::serialize() const
+{
+    std::ostringstream serializedJobCard;
+    serializedJobCard << m_id << ','
+        << m_bookingId << ','
+        << m_serviceId << ','
+        << m_technicianId << ','
+        << m_assignedDate.toString() << ','
+        << util::getServiceJobStatusString(m_status) << ','
+        << m_completionDate.toString();
+    return serializedJobCard.str();
+}
+
+/*
+Function: deserialize
+Description: Deserializes a CSV-formatted string into a JobCard object.
+Parameters:
+    - record: const std::string&, serialized job card record
+Returns:
+    - JobCard*: Pointer to the deserialized JobCard object
+Throws:
+    - std::runtime_error if timestamp parsing fails
+*/
+JobCard* JobCard::deserialize(const std::string& record)
+{
+    std::string id, bookingId, serviceId, technicianId;
+    std::string assignedDateString, statusString, completionDateString;
+    std::istringstream serializedJobCard(record);
+    getline(serializedJobCard, id, ',');
+    getline(serializedJobCard, bookingId, ',');
+    getline(serializedJobCard, serviceId, ',');
+    getline(serializedJobCard, technicianId, ',');
+    getline(serializedJobCard, assignedDateString, ',');
+    getline(serializedJobCard, statusString, ',');
+    getline(serializedJobCard, completionDateString, ',');
+    util::Timestamp assignedDate;
+    util::Timestamp completionDate;
+    try
+    {
+        assignedDate = util::Timestamp::fromString(assignedDateString);
+        completionDate = util::Timestamp::fromString(completionDateString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid timestamp");
+    }
+    util::ServiceJobStatus status = util::getServiceJobStatus(statusString);
+    return Factory::getObject<JobCard>(
+        id,
+        bookingId,
+        serviceId,
+        technicianId,
+        assignedDate,
+        status,
+        completionDate
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for job card serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,BookingID,ServiceID,TechnicianID,AssignedDate,Status,CompletionDate")
+*/
+std::string JobCard::getHeaders()
+{
+    return "ID,BookingID,ServiceID,TechnicianID,AssignedDate,Status,CompletionDate";
 }

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

@@ -1,7 +1,16 @@
+/*
+File: JobCard.h
+Description: Header file declaring the JobCard class, which represents
+             a service job card containing booking, service, technician,
+             and status details.
+Author: Trenser
+Date:19-May-2026
+*/
+
 #pragma once
 #include <string>
-#include "Timestamp.h"
 #include "Enums.h"
+#include "Timestamp.h"
 
 class ServiceBooking;
 class Service;
@@ -21,7 +30,6 @@ private:
     util::Timestamp m_assignedDate;
     util::ServiceJobStatus m_status;
     util::Timestamp m_completionDate;
-
 public:
     JobCard();
     JobCard(const std::string& bookingId,
@@ -34,6 +42,14 @@ public:
         util::ServiceJobStatus status,
         const util::Timestamp& completionDate
     );
+    JobCard(const std::string& id,
+        const std::string& bookingId,
+        const std::string& serviceId,
+        const std::string& technicianId,
+        const util::Timestamp& assignedDate,
+        util::ServiceJobStatus status,
+        const util::Timestamp& completionDate
+    );
     const std::string& getId() const;
     const std::string& getBookingId() const;
     ServiceBooking* getBooking() const;
@@ -54,4 +70,7 @@ public:
     void setAssignedDate(const util::Timestamp& assignedDate);
     void setStatus(util::ServiceJobStatus status);
     void setCompletionDate(const util::Timestamp& completionDate);
+    std::string serialize() const;
+    static JobCard* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

@@ -1,11 +1,42 @@
+/*
+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 <sstream>
 #include "Notification.h"
+#include "StringHelper.h"
+#include "Factory.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,62 +45,243 @@ Notification::Notification(const std::string& recipientUserId, User* recipient,
     m_message(message),
     m_createdAt(createdAt) {}
 
+/*
+Function: Notification (parameterized constructor with ID)
+Description: Initializes a notification with an existing ID, recipient details,
+             title, message, and creation timestamp. Updates UID tracking based on ID.
+Parameters:
+    - id: const std::string&, unique notification ID
+    - recipientUserId: const std::string&, ID of the recipient user
+    - title: const std::string&, notification title
+    - message: const std::string&, notification message
+    - createdAt: const util::Timestamp&, timestamp of creation
+Returns:
+    - A new Notification object
+*/
+Notification::Notification(const std::string& id, const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt)
+    : m_id(id),
+    m_recipientUserId(recipientUserId),
+    m_recipient(nullptr),
+    m_title(title),
+    m_message(message),
+    m_createdAt(createdAt) 
+{
+    int idNumber = util::extractNumber(m_id);
+    if (idNumber > m_uid)
+    {
+        m_uid = idNumber;
+    }
+}
+
+/*
+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;
+}
+
+/*
+Function: serialize
+Description: Serializes the notification into a CSV-formatted string.
+Parameters:
+    - None
+Returns:
+    - std::string: Serialized notification record
+*/
+std::string Notification::serialize() const
+{
+    std::ostringstream serializedNotification;
+    serializedNotification << m_id << ','
+        << m_recipientUserId << ','
+        << m_title << ','
+        << m_message << ','
+        << m_createdAt.toString();
+    return serializedNotification.str();
+}
+
+/*
+Function: deserialize
+Description: Deserializes a CSV-formatted string into a Notification object.
+Parameters:
+    - record: const std::string&, serialized notification record
+Returns:
+    - Notification*: Pointer to the deserialized Notification object
+Throws:
+    - std::runtime_error if timestamp parsing fails
+*/
+Notification* Notification::deserialize(const std::string& record)
+{
+    std::string id, recipientUserId, title, message, createdAtTimestampString;
+    std::istringstream serializedNotification(record);
+    getline(serializedNotification, id, ',');
+    getline(serializedNotification, recipientUserId, ',');
+    getline(serializedNotification, title, ',');
+    getline(serializedNotification, message, ',');
+    getline(serializedNotification, createdAtTimestampString, ',');
+    util::Timestamp createdAtTimestamp;
+    try
+    {
+        createdAtTimestamp = util::Timestamp::fromString(createdAtTimestampString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid createdAt timestamp");
+    }
+    return Factory::getObject<Notification>(
+        id,
+        recipientUserId,
+        title,
+        message,
+        createdAtTimestamp
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for notification serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,RecipientID,Title,Message,Timestamp")
+*/
+std::string Notification::getHeaders()
+{
+    return "ID,RecipientID,Title,Message,Timestamp";
 }

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"
@@ -17,6 +25,7 @@ private:
 public:
     Notification();
     Notification(const std::string& recipientUserId, User* recipient, const std::string& title, const std::string& message, const util::Timestamp& createdAt);
+    Notification(const std::string& id, const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt);
     const std::string& getId() const;
     const std::string& getRecipientUserId() const;
     User* getRecipient() const;
@@ -29,4 +38,7 @@ public:
     void setTitle(const std::string& title);
     void setMessage(const std::string& message);
     void setCreatedAt(const util::Timestamp& createdAt);
+    std::string serialize() const;
+    static Notification* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

@@ -1,65 +1,337 @@
+/*
+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 <sstream>
 #include "Service.h"
+#include "InventoryItem.h"
+#include "StringHelper.h"
+#include "Factory.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),
     m_requiredInventoryItems(requiredInventoryItems),
     m_status(util::State::ACTIVE),
-    m_laborCost(laborCost) {}
+    m_laborCost(laborCost) 
+{
+    int numberOfInventoryItems = m_requiredInventoryItems.getSize();
+    auto inventoryItemPointers = m_requiredInventoryItems.getValues();
+    for (int index = 0; index < numberOfInventoryItems; index++)
+    {
+        m_requiredInventoryItemIDs.push_back(inventoryItemPointers[index]->getId());
+    }
+}
 
+/*
+Function: Service (parameterized constructor with ID)
+Description: Initializes a service with an existing ID, name, inventory item IDs,
+             labor cost, and state. Updates UID tracking based on ID.
+Parameters:
+    - id: const std::string&, unique service ID
+    - name: const std::string&, name of the service
+    - requiredInventoryItemIDs: const util::Vector<std::string>&, IDs of required inventory items
+    - laborCost: double, labor cost of the service
+    - status: util::State, state of the service (ACTIVE/INACTIVE)
+Returns:
+    - A new Service object
+*/
+Service::Service(const std::string& id, const std::string& name, const util::Vector<std::string>& requiredInventoryItemIDs, double laborCost, util::State status)
+    : m_id(id),
+    m_name(name),
+    m_requiredInventoryItemIDs(requiredInventoryItemIDs),
+    m_status(status),
+    m_laborCost(laborCost)
+{
+    int idNumber = util::extractNumber(m_id);
+    if (idNumber > m_uid)
+    {
+        m_uid = idNumber;
+    }
+}
+
+/*
+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: getRequiredInventoryItemIDs
+Description: Retrieves the IDs of required inventory items for the service.
+Parameters:
+    - None
+Returns:
+    - const util::Vector<std::string>&: Inventory item IDs
+*/
+const util::Vector<std::string>& Service::getRequiredInventoryItemIDs() const
+{
+    return m_requiredInventoryItemIDs;
+}
+
+/*
+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;
+    m_requiredInventoryItemIDs.clear();
+    int numberOfRequiredInventoryItems = m_requiredInventoryItems.getSize();
+    auto inventoryItemPointers = m_requiredInventoryItems.getValues();
+    for (int index = 0; index < numberOfRequiredInventoryItems; index++)
+    {
+        m_requiredInventoryItemIDs.push_back(inventoryItemPointers[index]->getId());
+    }
 }
 
+/*
+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;
+}
+
+/*
+Function: getInventoryItemIDsAsString (static helper)
+Description: Converts a vector of inventory item IDs into a single string separated by '|'.
+Parameters:
+    - inventoryItemIds: const util::Vector<std::string>&, vector of inventory item IDs
+Returns:
+    - std::string: Concatenated inventory item IDs string
+*/
+static std::string getInventoryItemIDsAsString(const util::Vector<std::string>& inventoryItemIds)
+{
+    int numberOfInventoryItems = inventoryItemIds.getSize();
+    std::string inventoryItemIDs;
+    for (int index = 0; index < numberOfInventoryItems; index++)
+    {
+        inventoryItemIDs += inventoryItemIds[index];
+        if (index < numberOfInventoryItems - 1)
+        {
+            inventoryItemIDs += '|';
+        }
+    }
+    return inventoryItemIDs;
+}
+
+/*
+Function: getInventoryItemIDsAsVector (static helper)
+Description: Converts a string of inventory item IDs separated by '|' into a vector.
+Parameters:
+    - inventoryItemIDsString: const std::string&, concatenated inventory item IDs string
+Returns:
+    - util::Vector<std::string>: Vector of inventory item IDs
+*/
+static util::Vector<std::string> getInventoryItemIDsAsVector(const std::string& inventoryItemIDsString)
+{
+    util::Vector<std::string> inventoryItemIDs;
+    std::string inventoryItemID;
+    std::istringstream serializedInventoryItemIDs(inventoryItemIDsString);
+    while (getline(serializedInventoryItemIDs, inventoryItemID, '|'))
+    {
+        inventoryItemIDs.push_back(inventoryItemID);
+    }
+    return inventoryItemIDs;
+}
+
+/*
+Function: serialize
+Description: Serializes the service into a CSV-formatted string.
+Parameters:
+    - None
+Returns:
+    - std::string: Serialized service record
+*/
+std::string Service::serialize() const
+{
+    std::ostringstream serializedService;
+    serializedService << m_id << ','
+        << m_name << ','
+        << getInventoryItemIDsAsString(m_requiredInventoryItemIDs) << ','
+        << m_laborCost << ','
+        << util::getStateString(m_status);
+    return serializedService.str();
+}
+
+/*
+Function: deserialize
+Description: Deserializes a CSV-formatted string into a Service object.
+Parameters:
+    - record: const std::string&, serialized service record
+Returns:
+    - Service*: Pointer to the deserialized Service object
+Throws:
+    - std::runtime_error if labor cost parsing fails
+*/
+Service* Service::deserialize(const std::string& record)
+{
+    std::string id, name;
+    std::string inventoryItemIDsString, laborCostString, statusString;
+    double laborCost;
+    std::istringstream serializedService(record);
+    getline(serializedService, id, ',');
+    getline(serializedService, name, ',');
+    getline(serializedService, inventoryItemIDsString, ',');
+    getline(serializedService, laborCostString, ',');
+    getline(serializedService, statusString, ',');
+    util::Vector<std::string> inventoryItemIDs = getInventoryItemIDsAsVector(inventoryItemIDsString);
+    try
+    {
+        laborCost = std::stod(laborCostString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid labor cost");
+    }
+    util::State status = util::getState(statusString);
+    return Factory::getObject<Service>(
+        id,
+        name,
+        inventoryItemIDs,
+        laborCost,
+        status
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for service serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,Name,InventoryIDs,LaborCost,Status")
+*/
+std::string Service::getHeaders()
+{
+    return "ID,Name,InventoryIDs,LaborCost,Status";
 }

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

@@ -1,6 +1,16 @@
+/*
+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"
+#include "Vector.h"
 #include "Enums.h"
 
 class InventoryItem;
@@ -11,14 +21,17 @@ private:
     static int m_uid;
     std::string m_id;
     std::string m_name;
+    util::Vector<std::string> m_requiredInventoryItemIDs;
     util::Map<std::string, InventoryItem*> m_requiredInventoryItems;
     double m_laborCost;
     util::State m_status;
 public:
     Service();
     Service(const std::string& name, const util::Map<std::string, InventoryItem*>& requiredInventoryItems, double laborCost);
+    Service(const std::string& id, const std::string& name, const util::Vector<std::string>& requiredInventoryItemIDs, double laborCost, util::State state);
     const std::string& getId() const;
     const std::string& getName() const;
+    const util::Vector<std::string>& getRequiredInventoryItemIDs() const;
     const util::Map<std::string, InventoryItem*>& getRequiredInventoryItems() const;
     double getLaborCost() const;
     util::State getState() const;
@@ -27,4 +40,7 @@ public:
     void setRequiredInventoryItems(const util::Map<std::string, InventoryItem*>& requiredInventoryItems);
     void setLaborCost(double laborCost);
     void setState(util::State status);
+    std::string serialize() const;
+    static Service* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

@@ -1,14 +1,52 @@
+/*
+File: ServiceBooking.cpp
+Description: Implementation file containing the method definitions of the
+             ServiceBooking class, including constructors, getters, and setters
+             for booking attributes.
+Author: Trenser
+Date:19-May-2026
+*/
+#include <stdexcept>
+#include <sstream>
 #include "ServiceBooking.h"
+#include "Service.h"
+#include "Enums.h"
+#include "Factory.h"
+#include "StringHelper.h"
 
 int ServiceBooking::m_uid = 0;
 
+/*
+Function: ServiceBooking
+Description: Default constructor that initializes a new service booking with a unique ID,
+             null customer, and zero discount percentage.
+Parameters: None
+Returns: A new ServiceBooking object.
+*/
 ServiceBooking::ServiceBooking()
-    : m_id("SRV" + std::to_string(++m_uid)),
+    : m_id("SBK" + std::to_string(++m_uid)),
     m_customer(nullptr),
+    m_assignedTechnician(nullptr),
+    m_status(util::ServiceJobStatus::PENDING),
     m_discountPercentage(0.0) {}
 
+/*
+Function: ServiceBooking
+Description: Parameterized constructor that initializes a new service booking with a unique ID and specified details.
+Parameters:
+    - id: Booking ID string.
+    - status: Current status of the booking (e.g., PENDING, COMPLETED).
+    - services: Map of services included in the booking.
+    - customerId: ID of the customer.
+    - customer: Pointer to the User object representing the customer.
+    - vehicleNumber: Vehicle registration number.
+    - vehicleBrand: Brand of the vehicle.
+    - vehicleModel: Model of the vehicle.
+    - discountPercentage: Discount applied to the booking.
+Returns:
+    - A new ServiceBooking object.
+*/
 ServiceBooking::ServiceBooking(
-    const std::string& id,
     util::ServiceJobStatus status,
     const util::Map<std::string,
     Service*>& services,
@@ -17,11 +55,9 @@ ServiceBooking::ServiceBooking(
     const std::string& vehicleNumber,
     const std::string& vehicleBrand,
     const std::string& vehicleModel,
-    const std::string& assignedTechnicianId,
-    const User* assignedTechnician,
     double discountPercentage
 )
-    : m_id("SRV" + std::to_string(++m_uid)),
+    : m_id("SBK" + std::to_string(++m_uid)),
     m_status(status),
     m_services(services),
     m_customerId(customerId),
@@ -29,118 +65,456 @@ ServiceBooking::ServiceBooking(
     m_vehicleNumber(vehicleNumber),
     m_vehicleBrand(vehicleBrand),
     m_vehicleModel(vehicleModel),
-    m_assignedTechnicianId(assignedTechnicianId),
-    m_assignedTechnician(assignedTechnician),
+    m_assignedTechnicianId(""),
+    m_assignedTechnician(nullptr),
     m_discountPercentage(discountPercentage)
 {
+    int numberOfServices = m_services.getSize();
+    auto servicePointers = m_services.getValues();
+    for (int index = 0; index < numberOfServices; index++)
+    {
+        m_serviceIDs.push_back(servicePointers[index]->getId());
+    }
 }
 
+/*
+Function: ServiceBooking (parameterized constructor with ID)
+Description: Initializes a service booking with an existing ID, status, service IDs,
+             customer details, vehicle details, technician ID, and discount percentage.
+             Updates UID tracking based on ID.
+Parameters:
+    - id: const std::string&, unique booking ID
+    - status: util::ServiceJobStatus, job status of the booking
+    - serviceIDs: const util::Vector<std::string>&, IDs of booked services
+    - customerId: const std::string&, ID of the customer
+    - vehicleNumber: const std::string&, vehicle number
+    - vehicleBrand: const std::string&, vehicle brand
+    - vehicleModel: const std::string&, vehicle model
+    - assignedTechnicianId: const std::string&, ID of the assigned technician
+    - discountPercentage: double, discount applied
+Returns:
+    - A new ServiceBooking object
+*/
+ServiceBooking::ServiceBooking(
+    const std::string& id,
+    util::ServiceJobStatus status,
+    const util::Vector<std::string>& serviceIDs,
+    const std::string& customerId,
+    const std::string& vehicleNumber,
+    const std::string& vehicleBrand,
+    const std::string& vehicleModel,
+    const std::string& assignedTechnicianId,
+    double discountPercentage
+)
+    : m_id(id),
+    m_status(status),
+    m_serviceIDs(serviceIDs),
+    m_customerId(customerId),
+    m_customer(nullptr),
+    m_vehicleNumber(vehicleNumber),
+    m_vehicleBrand(vehicleBrand),
+    m_vehicleModel(vehicleModel),
+    m_assignedTechnicianId(assignedTechnicianId),
+    m_assignedTechnician(nullptr),
+    m_discountPercentage(discountPercentage)
+{
+    int idNumber = util::extractNumber(m_id);
+    if (idNumber > m_uid)
+    {
+        m_uid = idNumber;
+    }
+}
+
+/*
+Function: getId
+Description: Retrieves the unique identifier of the service booking.
+Parameter: None
+Return type: const std::string&
+*/
 const std::string& ServiceBooking::getId() const
 {
     return m_id;
 }
 
+/*
+Function: getStatus
+Description: Retrieves the current status of the service booking.
+Parameter: None
+Return type: util::ServiceJobStatus
+*/
 util::ServiceJobStatus ServiceBooking::getStatus() const
 {
     return m_status;
 }
 
+/*
+Function: getServiceIDs
+Description: Retrieves the IDs of services booked.
+Parameters:
+    - None
+Returns:
+    - const util::Vector<std::string>&: Service IDs
+*/
+const util::Vector<std::string>& ServiceBooking::getServiceIDs() const
+{
+    return m_serviceIDs;
+}
+
+/*
+Function: getServices
+Description: Retrieves the services associated with the booking.
+Parameter: None
+Return type: const util::Map<std::string, Service*>&
+*/
+/*
+Function: getServices
+Description: Retrieves the services associated with the booking.
+Parameter: None
+Return type: const util::Map<std::string, Service*>&
+*/
 const util::Map<std::string, Service*>& ServiceBooking::getServices() const
 {
     return m_services;
 }
 
+/*
+Function: getCustomerId
+Description: Retrieves the customer ID associated with the booking.
+Parameter: None
+Return type: const std::string&
+*/
 const std::string& ServiceBooking::getCustomerId() const
 {
     return m_customerId;
 }
 
+/*
+Function: getCustomer
+Description: Retrieves the customer object associated with the booking.
+Parameter: None
+Return type: User*
+*/
 User* ServiceBooking::getCustomer() const
 {
     return m_customer;
 }
 
+/*
+Function: getVehicleNumber
+Description: Retrieves the vehicle registration number for the booking.
+Parameter: None
+Return type: const std::string&
+*/
 const std::string& ServiceBooking::getVehicleNumber() const
 {
     return m_vehicleNumber;
 }
 
+/*
+Function: getVehicleBrand
+Description: Retrieves the brand of the vehicle for the booking.
+Parameter: None
+Return type: const std::string&
+*/
 const std::string& ServiceBooking::getVehicleBrand() const
 {
     return m_vehicleBrand;
 }
 
+/*
+Function: getVehicleModel
+Description: Retrieves the model of the vehicle for the booking.
+Parameter: None
+Return type: const std::string&
+*/
 const std::string& ServiceBooking::getVehicleModel() const
 {
     return m_vehicleModel;
 }
 
+/*
+Function: getAssignedTechnicianId
+Description: Retrieves the ID of the technician assigned to the booking.
+Parameter: None
+Return type: const std::string&
+*/
 const std::string& ServiceBooking::getAssignedTechnicianId() const
 {
     return m_assignedTechnicianId;
 }
 
-const User* ServiceBooking::getAssignedTechnician() const
+/*
+Function: getAssignedTechnician
+Description: Retrieves the technician object assigned to the booking.
+Parameter: None
+Return type: User*
+*/
+User* ServiceBooking::getAssignedTechnician() const
 {
     return m_assignedTechnician;
 }
-
+/*
+Function: getDiscountPercentage
+Description: Retrieves the discount percentage applied to the booking.
+Parameter: None
+Return type: double
+*/
 double ServiceBooking::getDiscountPercentage() const
 {
     return m_discountPercentage;
 }
 
+/*
+Function: setId
+Description: Sets the unique identifier of the service booking.
+Parameter: const std::string& id - new booking ID
+Return type: void
+*/
 void ServiceBooking::setId(const std::string& id)
 {
     m_id = id;
 }
 
+/*
+Function: setStatus
+Description: Sets the current status of the service booking.
+Parameter: const util::ServiceJobStatus& status - new booking status
+Return type: void
+*/
 void ServiceBooking::setStatus(const util::ServiceJobStatus& status)
 {
     m_status = status;
 }
 
+/*
+Function: setServices
+Description: Sets the services associated with the booking.
+Parameter: const util::Map<std::string, Service*>& services - new services map
+Return type: void
+*/
 void ServiceBooking::setServices(const util::Map<std::string, Service*>& services)
 {
     m_services = services;
+    m_serviceIDs.clear();
+    int numberOfServices = m_services.getSize();
+    auto servicePointers = m_services.getValues();
+    for (int index = 0; index < numberOfServices; index++)
+    {
+        m_serviceIDs.push_back(servicePointers[index]->getId());
+    }
 }
 
+/*
+Function: setCustomerId
+Description: Sets the customer ID for the booking.
+Parameter: const std::string& customerId - new customer ID
+Return type: void
+*/
 void ServiceBooking::setCustomerId(const std::string& customerId)
 {
     m_customerId = customerId;
 }
 
+/*
+Function: setCustomer
+Description: Sets the customer object for the booking.
+Parameter: User* customer - pointer to the customer object
+Return type: void
+*/
 void ServiceBooking::setCustomer(User* customer)
 {
     m_customer = customer;
 }
 
+/*
+Function: setVehicleNumber
+Description: Sets the vehicle registration number for the booking.
+Parameter: const std::string& vehicleNumber - new vehicle number
+Return type: void
+*/
 void ServiceBooking::setVehicleNumber(const std::string& vehicleNumber)
 {
     m_vehicleNumber = vehicleNumber;
 }
 
+/*
+Function: setVehicleBrand
+Description: Sets the brand of the vehicle for the booking.
+Parameter: const std::string& vehicleBrand - new vehicle brand
+Return type: void
+*/
 void ServiceBooking::setVehicleBrand(const std::string& vehicleBrand)
 {
     m_vehicleBrand = vehicleBrand;
 }
 
+/*
+Function: setVehicleModel
+Description: Sets the model of the vehicle for the booking.
+Parameter: const std::string& vehicleModel - new vehicle model
+Return type: void
+*/
 void ServiceBooking::setVehicleModel(const std::string& vehicleModel)
 {
     m_vehicleModel = vehicleModel;
 }
 
+/*
+Function: setAssignedTechnicianId
+Description: Sets the ID of the technician assigned to the booking.
+Parameter: const std::string& assignedTechnicianId - new technician ID
+Return type: void
+*/
 void ServiceBooking::setAssignedTechnicianId(const std::string& assignedTechnicianId)
 {
     m_assignedTechnicianId = assignedTechnicianId;
 }
 
-void ServiceBooking::setAssignedTechnician(const User* assignedTechnician)
+/*
+Function: setAssignedTechnician
+Description: Sets the technician object assigned to the booking.
+Parameter: User* assignedTechnician - pointer to the technician object
+Return type: void
+*/
+void ServiceBooking::setAssignedTechnician(User* assignedTechnician)
 {
     m_assignedTechnician = assignedTechnician;
 }
 
+/*
+Function: setDiscountPercentage
+Description: Sets the discount percentage for the booking.
+Parameter: double discountPercentage - new discount percentage
+Return type: void
+*/
 void ServiceBooking::setDiscountPercentage(double discountPercentage)
 {
     m_discountPercentage = discountPercentage;
+}
+
+/*
+Function: getServiceIDsAsString (static helper)
+Description: Converts a vector of service IDs into a single string separated by '|'.
+Parameters:
+    - serviceIDs: const util::Vector<std::string>&, vector of service IDs
+Returns:
+    - std::string: Concatenated service IDs string
+*/
+static std::string getServiceIDsAsString(const util::Vector<std::string>& serviceIDs)
+{
+    int numberOfServices = serviceIDs.getSize();
+    std::string serviceIDsString;
+    for (int index = 0; index < numberOfServices; index++)
+    {
+        serviceIDsString += serviceIDs[index];
+        if (index < numberOfServices - 1)
+        {
+            serviceIDsString += '|';
+        }
+    }
+    return serviceIDsString;
+}
+
+/*
+Function: getServiceIDsAsVector (static helper)
+Description: Converts a string of service IDs separated by '|' into a vector.
+Parameters:
+    - serviceIDsString: const std::string&, concatenated service IDs string
+Returns:
+    - util::Vector<std::string>: Vector of service IDs
+*/
+static util::Vector<std::string> getServiceIDsAsVector(const std::string& serviceIDsString)
+{
+    util::Vector<std::string> serviceIDs;
+    std::string serviceID;
+    std::istringstream serializedServiceIDs(serviceIDsString);
+    while (getline(serializedServiceIDs, serviceID, '|'))
+    {
+        serviceIDs.push_back(serviceID);
+    }
+    return serviceIDs;
+}
+
+/*
+Function: serialize
+Description: Serializes the service booking into a CSV-formatted string.
+Parameters:
+    - None
+Returns:
+    - std::string: Serialized booking record
+*/
+std::string ServiceBooking::serialize() const
+{
+    std::ostringstream serializedBooking;
+    serializedBooking << m_id << ','
+        << util::getServiceJobStatusString(m_status) << ','
+        << getServiceIDsAsString(m_serviceIDs) << ','
+        << m_customerId << ','
+        << m_vehicleNumber << ','
+        << m_vehicleBrand << ','
+        << m_vehicleModel << ','
+        << m_assignedTechnicianId << ','
+        << m_discountPercentage << ',';
+    return serializedBooking.str();
+}
+
+/*
+Function: deserialize
+Description: Deserializes a CSV-formatted string into a ServiceBooking object.
+Parameters:
+    - record: const std::string&, serialized booking record
+Returns:
+    - ServiceBooking*: Pointer to the deserialized ServiceBooking object
+Throws:
+    - std::runtime_error if discount percentage parsing fails
+*/
+ServiceBooking* ServiceBooking::deserialize(const std::string& record)
+{
+    std::string id, customerId, vehicleNumber, vehicleBrand, vehicleModel, assignedTechnicianId;
+    std::string serviceJobStatusString, serviceIDsString, discountPercentageString;
+    double discountPercentage;
+    std::istringstream serializedBooking(record);
+    getline(serializedBooking, id, ',');
+    getline(serializedBooking, serviceJobStatusString, ',');
+    getline(serializedBooking, serviceIDsString, ',');
+    getline(serializedBooking, customerId, ',');
+    getline(serializedBooking, vehicleNumber, ',');
+    getline(serializedBooking, vehicleBrand, ',');
+    getline(serializedBooking, vehicleModel, ',');
+    getline(serializedBooking, assignedTechnicianId, ',');
+    getline(serializedBooking, discountPercentageString, ',');
+    util::Vector<std::string> serviceIDs = getServiceIDsAsVector(serviceIDsString);
+    try
+    {
+        discountPercentage = std::stod(discountPercentageString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid discount percentage");
+    }
+    util::ServiceJobStatus status = util::getServiceJobStatus(serviceJobStatusString);
+    return Factory::getObject<ServiceBooking>(
+        id,
+        status,
+        serviceIDs,
+        customerId,
+        vehicleNumber,
+        vehicleBrand,
+        vehicleModel,
+        assignedTechnicianId,
+        discountPercentage
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for service booking serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,Status,ServiceIDs,CustomerID,VehicleNumber,VehicleBrand,VehicleModel,AssignedTechnicianID,DiscountPercentage")
+*/
+std::string ServiceBooking::getHeaders()
+{
+    return "ID,Status,ServiceIDs,CustomerID,VehicleNumber,VehicleBrand,VehicleModel,AssignedTechnicianID,DiscountPercentage";
 }

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

@@ -1,6 +1,15 @@
+/*
+File: ServiceBooking.h
+Description: Header file declaring the ServiceBooking class, which represents
+             a booking of services by a customer, including vehicle details,
+             assigned technician, and discount information.
+Author: Trenser
+Date:19-May-2026
+*/
 #pragma once
 #include <string>
 #include "Map.h"
+#include "Vector.h"
 #include "Enums.h"
 
 class Service;
@@ -12,6 +21,7 @@ private:
     static int m_uid;
     std::string m_id;
     util::ServiceJobStatus m_status;
+    util::Vector<std::string> m_serviceIDs;
     util::Map<std::string, Service*> m_services;
     std::string m_customerId;
     User* m_customer;
@@ -19,12 +29,11 @@ private:
     std::string m_vehicleBrand;
     std::string m_vehicleModel;
     std::string m_assignedTechnicianId;
-    const User* m_assignedTechnician;
+    User* m_assignedTechnician;
     double m_discountPercentage;
 public:
     ServiceBooking();
     ServiceBooking(
-        const std::string& id,
         util::ServiceJobStatus status,
         const util::Map<std::string,
         Service*>& services,
@@ -33,12 +42,22 @@ public:
         const std::string& vehicleNumber,
         const std::string& vehicleBrand,
         const std::string& vehicleModel,
+        double discountPercentage
+    );
+    ServiceBooking(
+        const std::string& id,
+        util::ServiceJobStatus status,
+        const util::Vector<std::string>& serviceIDs,
+        const std::string& customerId,
+        const std::string& vehicleNumber,
+        const std::string& vehicleBrand,
+        const std::string& vehicleModel,
         const std::string& assignedTechnicianId,
-        const User* assignedTechnician,
         double discountPercentage
     );
     const std::string& getId() const;
     util::ServiceJobStatus getStatus() const;
+    const util::Vector<std::string>& getServiceIDs() const;
     const util::Map<std::string, Service*>& getServices() const;
     const std::string& getCustomerId() const;
     User* getCustomer() const;
@@ -46,7 +65,7 @@ public:
     const std::string& getVehicleBrand() const;
     const std::string& getVehicleModel() const;
     const std::string& getAssignedTechnicianId() const;
-    const User* getAssignedTechnician() const;
+    User* getAssignedTechnician() const;
     double getDiscountPercentage() const;
     void setId(const std::string& id);
     void setStatus(const util::ServiceJobStatus& status);
@@ -57,6 +76,9 @@ public:
     void setVehicleBrand(const std::string& vehicleBrand);
     void setVehicleModel(const std::string& vehicleModel);
     void setAssignedTechnicianId(const std::string& assignedTechnicianId);
-    void setAssignedTechnician(const User* assignedTechnician);
+    void setAssignedTechnician(User* assignedTechnician);
     void setDiscountPercentage(double discountPercentage);
+    std::string serialize() const;
+    static ServiceBooking* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

@@ -1,14 +1,48 @@
+/*
+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 <sstream>
 #include "User.h"
 #include "Notification.h"
 #include "Enums.h"
+#include "Factory.h"
+#include "StringHelper.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,104 +53,339 @@ User::User(const std::string& userName, const std::string& password, const std::
     m_type(role),
     m_status(util::State::ACTIVE) {}
 
-User::~User()
+/*
+Function: User (parameterized constructor with ID)
+Description: Initializes a user with an existing ID, credentials, personal details,
+             role, and state. Updates UID tracking based on ID.
+Parameters:
+    - userId: const std::string&, unique user ID
+    - userName: const std::string&, username
+    - password: const std::string&, password
+    - name: const std::string&, full name
+    - phone: const std::string&, phone number
+    - email: const std::string&, email address
+    - role: util::UserType, role of the user
+    - status: util::State, state of the user (ACTIVE/INACTIVE)
+Returns:
+    - A new User object
+*/
+User::User(const std::string& userId, const std::string& userName, const std::string& password, const std::string& name, const std::string& phone, const std::string& email, util::UserType role, util::State status)
+    : m_id(userId),
+    m_userName(userName),
+    m_password(password),
+    m_name(name),
+    m_phone(phone),
+    m_email(email),
+    m_type(role),
+    m_status(status)
 {
-    for (int index = 0; index < m_notifications.getSize(); index++)
+    int idNumber = util::extractNumber(m_id);
+    if (idNumber > m_uid)
     {
-        delete m_notifications.getValues()[index];
+        m_uid = idNumber;
     }
 }
 
+/*
+Function: ~User
+Description: Destructor that cleans up dynamically allocated notifications associated with the user.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+User::~User()
+{
+    auto values = m_notifications.getValues();
+    for (int index = 0; index < values.getSize(); index++)
+    {
+        delete values[index];
+    }
+}
+
+/*
+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)
 {
-    m_notifications.insert(notification->getId(), 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)
+/*
+Function: serialize
+Description: Serializes the user into a CSV-formatted string.
+Parameters:
+    - None
+Returns:
+    - std::string: Serialized user record
+*/
+std::string User::serialize() const
 {
+    std::ostringstream serializedUser;
+    serializedUser << m_id << ','
+        << m_userName << ','
+        << m_password << ','
+        << m_name << ','
+        << m_phone << ','
+        << m_email << ','
+        << util::getUserTypeString(m_type) << ','
+        << util::getStateString(m_status);
+    return serializedUser.str();
 }
+
+/*
+Function: deserialize
+Description: Deserializes a CSV-formatted string into a User object.
+Parameters:
+    - record: const std::string&, serialized user record
+Returns:
+    - User*: Pointer to the deserialized User object
+*/
+User* User::deserialize(const std::string& record)
+{
+    std::string id, name, username, phone, password, email;
+    std::string userTypeString, stateString;
+    std::istringstream serializedUser(record);
+    getline(serializedUser, id, ',');
+    getline(serializedUser, username, ',');
+    getline(serializedUser, password, ',');
+    getline(serializedUser, name, ',');
+    getline(serializedUser, phone, ',');
+    getline(serializedUser, email, ',');
+    getline(serializedUser, userTypeString, ',');
+    getline(serializedUser, stateString);
+    util::UserType userType = util::getUserType(userTypeString);
+    util::State status = util::getState(stateString);
+    return Factory::getObject<User>(id,
+        username,
+        password,
+        name,
+        phone,
+        email,
+        userType,
+        status);
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for user serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,Username,Password,Name,Phone,Email,UserType,UserStatus")
+*/
+std::string User::getHeaders()
+{
+    return "ID,Username,Password,Name,Phone,Email,UserType,UserStatus";
+}

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"
@@ -22,6 +31,7 @@ private:
 public:
     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);
+    User(const std::string& userId, const std::string& userName, const std::string& password, const std::string& name, const std::string& phone, const std::string& email, util::UserType role, util::State status);
     ~User();
     const std::string& getId() const;
     const std::string& getUserName() const;
@@ -38,8 +48,10 @@ 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;
+    std::string serialize() const;
+    static User* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

@@ -1,3 +1,82 @@
+/*
+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 <stdexcept>
 #include "AuthenticationManagementService.h"
+#include "User.h"
 
 User* AuthenticationManagementService::m_authenticatedUser = nullptr;
+
+/*
+Function: login
+Description: Authenticates a user by checking the provided username and password
+			 against the stored users in the DataStore. If successful, sets the
+			 authenticated user.
+Parameter: const std::string& username - user’s username
+		   const std::string& password - user’s password
+Return type: bool - true if login successful, false otherwise
+*/
+bool AuthenticationManagementService::login(const std::string& username, const std::string& password)
+{
+	util::Map<std::string, User*> users = m_dataStore.getUsers();
+	int usersMapSize = users.getSize();
+	for (int index = 0; index < usersMapSize; index++)
+	{
+		User* user = users.getValueAt(index);
+		if (username == user->getUserName())
+		{
+			if (password == user->getPassword())
+			{
+				m_authenticatedUser = user;
+				return true;
+			}
+			return false;
+		}
+	}
+	return false;
+}
+
+/*
+Function: getAuthenticatedUser
+Description: Retrieves the currently authenticated user.
+Parameter: None
+Return type: User* - pointer to the authenticated user
+*/
+User* AuthenticationManagementService::getAuthenticatedUser()
+{
+	return m_authenticatedUser;
+}
+
+/*
+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,3 +1,12 @@
+/*
+File: AuthenticationManagementService.h
+Description: Header file declaring the AuthenticationManagementService class, which manages
+             user authentication, login, logout, password changes, and retrieval of the
+             authenticated user.
+Author: Trenser
+Date:19-May-2026
+*/
+
 #pragma once
 #include <string>
 #include "DataStore.h"

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

@@ -1 +1,341 @@
+/*
+File: InventoryManagementService.cpp
+Description: Implements the InventoryManagementService class, which manages inventory
+			 items and observer relationships within the system. Provides methods
+			 for loading and saving inventory items from persistent storage, as well
+			 as attaching and persisting observers for notification handling.
+Author: Trenser
+Date: 22-May-2026
+*/
+
+#include <stdexcept>
+#include "Config.h"
+#include "Enums.h"
+#include "Factory.h"
+#include "FileManager.h"
+#include "InventoryItem.h"
 #include "InventoryManagementService.h"
+#include "Timestamp.h"
+#include "User.h"
+#include "Utility.h"
+#include "Vector.h"
+
+
+util::Map<std::string, User*> InventoryManagementService::m_observers{};
+
+/*
+Function: sendLowStockAlertsToAdmins (static helper)
+Description: Sends low stock alert notifications to all admin users for a given inventory item.
+Parameters:
+	- inventoryManagementService: InventoryManagementService&, service used to send notifications
+	- inventoryItem: const InventoryItem*, pointer to the low-stock inventory item
+	- adminUsers: const util::Vector<User*>&, list of admin users to notify
+Returns:
+	- None
+*/
+static void sendLowStockAlertsToAdmins(InventoryManagementService& inventoryManagementService, const InventoryItem* inventoryItem, const util::Vector<User*>& adminUsers)
+{
+	int adminUsersSize = adminUsers.getSize();
+	for (int index = 0; index < adminUsersSize; index++)
+	{
+		std::string title = "Low Stock Alert";
+		std::string message = "The inventory item with ID " + inventoryItem->getId() + " has very low quantity in the inventory";
+		inventoryManagementService.sendNotification(
+			adminUsers[index],
+			title,
+			message
+		);
+	}
+}
+
+/*
+Function: sendLowStockAlerts
+Description: Sends alerts to user for inventory items with low stock
+Parameters:
+	- None
+Returns:
+	- None
+*/
+void InventoryManagementService::sendLowStockAlerts()
+{
+	auto& inventoryItems = m_dataStore.getInventoryItems();
+	if (inventoryItems.isEmpty())
+	{
+		return;
+	}
+	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);
+		}
+	}
+}
+
+/*
+Function: getObserverIDs
+Description: Retrieves the IDs of all observers currently attached to the
+			 InventoryManagementService.
+Parameters:
+	- None
+Returns:
+	- util::Vector<std::string>: Vector of observer user IDs
+*/
+util::Vector<std::string> InventoryManagementService::getObserverIDs()
+{
+	util::Vector<std::string> observerIDs;
+	int numberOfObservers = m_observers.getSize();
+	for (int index = 0; index < numberOfObservers; index++)
+	{
+		User* observer = m_observers.getValueAt(index);
+		if (observer)
+		{
+			observerIDs.push_back(observer->getId());
+		}
+	}
+	return observerIDs;
+}
+
+/*
+Function: loadInventoryItems
+Description: Loads inventory items from persistent storage into the datastore.
+			 Uses FileManager to deserialize inventory items from the configured file.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void InventoryManagementService::loadInventoryItems()
+{
+	util::FileManager<InventoryItem> inventoryItemFileManager(config::file::INVENTORYITEM_FILE);
+	auto& inventoryItems = m_dataStore.getInventoryItems();
+	auto inventoryItemsMap = inventoryItemFileManager.load();
+	int numberOfInventoryItems = inventoryItemsMap.getSize();
+	for (int index = 0; index < numberOfInventoryItems; index++)
+	{
+		inventoryItems[inventoryItemsMap.getKeyAt(index)] = inventoryItemsMap.getValueAt(index);
+	}
+}
+
+/*
+Function: saveInventoryItems
+Description: Saves inventory items from the datastore to persistent storage.
+			 Uses FileManager to serialize inventory items into the configured file.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void InventoryManagementService::saveInventoryItems()
+{
+	util::FileManager<InventoryItem> inventoryItemFileManager(config::file::INVENTORYITEM_FILE);
+	auto& inventoryItems = m_dataStore.getInventoryItems();
+	inventoryItemFileManager.save(inventoryItems);
+}
+
+/*
+Function: loadObservers
+Description: Loads observer IDs from persistent storage and attaches corresponding
+			 users as observers to the InventoryManagementService.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void InventoryManagementService::loadObservers()
+{
+	util::loadObservers(config::file::INVENTORYMANAGEMENTOBSERVERS, this, m_dataStore);
+}
+
+/*
+Function: saveObservers
+Description: Saves the current observer IDs of the InventoryManagementService
+			 to persistent storage for future retrieval.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void InventoryManagementService::saveObservers()
+{
+	util::saveObservers(config::file::INVENTORYMANAGEMENTOBSERVERS, this);
+}
+
+/*
+Function: addInventoryItem
+Description: Creates a new inventory item using the Factory and inserts it
+             into the DataStore.
+Parameter: const std::string& partName - name of the part
+           int quantity - initial quantity of the part
+           double price - price of the part
+Return type: void
+*/
+void InventoryManagementService::addInventoryItem(const std::string& partName, int quantity, double price)
+{
+    InventoryItem* newItem = Factory::getObject<InventoryItem>(partName, quantity, price);
+    m_dataStore.getInventoryItems().insert(newItem->getId(), newItem);
+}
+
+/*
+Function: addInventoryItemStock
+Description: Increases the stock quantity of an existing inventory item.
+Parameter: const std::string& selectedItemId - ID of the inventory item
+           int quantity - quantity to add
+Return type: void
+*/
+void InventoryManagementService::addInventoryItemStock(const std::string& selectedItemId, int quantity)
+{
+    int index = m_dataStore.getInventoryItems().find(selectedItemId);
+    if (index != -1)
+    {
+        InventoryItem* item = m_dataStore.getInventoryItems().getValueAt(index);
+        if (item != nullptr)
+        {
+            int totalQuantity = item->getQuantity() + quantity;
+            item->setQuantity(totalQuantity);
+        }
+    }
+}
+
+/*
+Function: getInventoryItems
+Description: Retrieves all inventory items stored in the DataStore.
+Parameter: None
+Return type: util::Map<std::string, InventoryItem*>
+*/
+util::Map<std::string, InventoryItem*> InventoryManagementService::getInventoryItems()
+{
+	return m_dataStore.getInventoryItems();
+}
+
+/*
+Function: removeInventoryItem
+Description: Marks an inventory item as inactive instead of deleting it.
+Parameter: const std::string& inventoryItemID - ID of the inventory item
+Return type: void
+*/
+void InventoryManagementService::removeInventoryItem(const std::string& inventoryItemID)
+{
+    int index = m_dataStore.getInventoryItems().find(inventoryItemID);
+    if (index != -1)
+    {
+        InventoryItem* item = m_dataStore.getInventoryItems().getValueAt(index);
+        if (item != nullptr)
+        {
+            item->setState(util::State::INACTIVE);
+        }
+    }
+}
+
+/*
+Function: getInventoryItem
+Description: Retrieves a specific inventory item by its ID from the DataStore.
+Parameter: const std::string& inventoryItemID - ID of the inventory item
+Return type: InventoryItem*
+*/
+InventoryItem* InventoryManagementService::getInventoryItem(const std::string& inventoryItemID)
+{
+    int index = m_dataStore.getInventoryItems().find(inventoryItemID);
+    if (index != -1)
+    {
+        return m_dataStore.getInventoryItems().getValueAt(index);
+    }
+    return nullptr;
+}
+
+/*
+Function: attach
+Description: Adds a user to the observer list for receiving inventory notifications.
+Parameters:
+	- user: User*, pointer to the user to be attached as an observer
+Returns:
+	- None
+*/
+void InventoryManagementService::attach(User* user)
+{
+	if (user)
+	{
+		const std::string& userID = user->getId();
+		if (m_observers.find(userID) == -1)
+		{
+			m_observers[userID] = user;
+		}
+	}
+}
+
+/*
+Function: detach
+Description: Removes a user from the observer list so they no longer receive inventory notifications.
+Parameters:
+	- user: User*, pointer to the user to be detached from the observer list
+Returns:
+	- None
+*/
+void InventoryManagementService::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 subscribed as an observer.
+Parameters:
+	- user: User*, pointer to the user receiving the notification
+	- title: std::string, title of the notification
+	- message: std::string, body/content of the notification
+Returns:
+	- None
+Throws:
+	- std::runtime_error if notification creation fails
+*/
+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,
+					title,
+					message,
+					util::Timestamp()
+				);
+			if (notification)
+			{
+				user->addNotification(notification);
+			}
+			else
+			{
+				throw std::runtime_error("Failed to create notification");
+			}
+		}
+	}
+}
+

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

@@ -1,6 +1,16 @@
+/*
+File: InventoryManagementService.h
+Description: Header file declaring the InventoryManagementService class,
+             which manages inventory items, stock updates, and notifications
+             related to low stock alerts. Inherits from NotificationManagementService.
+Author: Trenser
+Date:19-May-2026
+*/
+
 #pragma once
 #include <string>
 #include "Map.h"
+#include "Vector.h"
 #include "NotificationManagementService.h"
 #include "DataStore.h"
 
@@ -11,14 +21,20 @@ class InventoryManagementService : public NotificationManagementService
 private:
     DataStore& m_dataStore;
     static util::Map<std::string, User*> m_observers;
+    util::Vector<std::string> getObserverIDs() override;
 public:
     InventoryManagementService() : m_dataStore(DataStore::getInstance()) {}
     util::Map<std::string, InventoryItem*> getInventoryItems();
     InventoryItem* getInventoryItem(const std::string& inventoryItemID);
     void addInventoryItem(const std::string& partName, int quantity, double price);
     void removeInventoryItem(const std::string& inventoryItemID);
+    void addInventoryItemStock(const std::string& selectedItemId, int quantity);
     void sendLowStockAlerts();
     void sendNotification(User* user, const std::string& title, const std::string& message) override;
     void attach(User* user) override;
     void detach(User* user) override;
+    void loadInventoryItems();
+    void saveInventoryItems();
+    void loadObservers();
+    void saveObservers();
 };

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
@@ -10,4 +19,5 @@ public:
 	virtual void sendNotification(User* recipient, const std::string& title, const std::string& message) = 0;
 	virtual void attach(User* user) = 0;
 	virtual void detach(User* user) = 0;
+	virtual util::Vector<std::string> getObserverIDs() = 0;
 };

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

@@ -1 +1,431 @@
+/*
+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 "Config.h"
+#include "Enums.h"
+#include "Factory.h"
+#include "FileManager.h"
+#include "InventoryItem.h"
+#include "Invoice.h"
+#include "JobCard.h"
 #include "PaymentManagementService.h"
+#include "Service.h"
+#include "ServiceBooking.h"
+#include "Timestamp.h"
+#include "User.h"
+#include "Utility.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,
+					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)
+					{
+						std::string title = "Payment Reminder";
+						std::string message = "Your payment for Invoice ID " + invoice->getId() + " is still pending. Please complete the payment.";
+						sendNotification(customer, title, message);
+					}
+				}
+			}
+		}
+	}
+}
+
+/*
+Function: getObserverIDs
+Description: Retrieves the IDs of all observers currently attached to the
+             PaymentManagementService.
+Parameters:
+    - None
+Returns:
+    - util::Vector<std::string>: Vector of observer user IDs
+*/
+util::Vector<std::string> PaymentManagementService::getObserverIDs()
+{
+	util::Vector<std::string> observerIDs;
+	int numberOfObservers = m_observers.getSize();
+	for (int index = 0; index < numberOfObservers; index++)
+	{
+		User* observer = m_observers.getValueAt(index);
+		if (observer)
+		{
+			observerIDs.push_back(observer->getId());
+		}
+	}
+	return observerIDs;
+}
+
+/*
+Function: loadInvoices
+Description: Loads invoices from persistent storage into the datastore.
+             Validates associated service bookings and inventory parts before
+             attaching them to each invoice. Throws exceptions if invalid IDs
+             are encountered.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a booking ID or part ID is invalid
+*/
+void PaymentManagementService::loadInvoices()
+{
+    util::FileManager<Invoice> invoiceFileManager(config::file::INVOICE_FILE);
+    auto& invoices = m_dataStore.getInvoices();
+    auto& serviceBookings = m_dataStore.getServiceBookings();
+    auto& inventoryItems = m_dataStore.getInventoryItems();
+    auto invoicesMap = invoiceFileManager.load();
+    for (int invoiceIndex = 0; invoiceIndex < invoicesMap.getSize(); invoiceIndex++)
+    {
+        Invoice* invoice = invoicesMap.getValueAt(invoiceIndex);
+        int bookingIndex = serviceBookings.find(invoice->getBookingId());
+        if (bookingIndex == -1)
+        {
+            throw std::runtime_error("Invalid Booking ID");
+        }
+        ServiceBooking* booking = serviceBookings.getValueAt(bookingIndex);
+        invoice->setBooking(booking);
+        util::Map<std::string, InventoryItem*> invoiceParts;
+        auto& partIDs = invoice->getPartIDs();
+        for (int partIndex = 0; partIndex < partIDs.getSize(); partIndex++)
+        {
+            const std::string& partID = partIDs[partIndex];
+            int inventoryIndex = inventoryItems.find(partID);
+            if (inventoryIndex == -1)
+            {
+                throw std::runtime_error("Invalid Part ID");
+            }
+            invoiceParts[partID] = inventoryItems.getValueAt(inventoryIndex);
+        }
+        invoice->setParts(invoiceParts);
+        invoices[invoice->getId()] = invoice;
+    }
+}
+
+/*
+Function: saveInvoices
+Description: Saves invoices from the datastore to persistent storage.
+             Uses FileManager to serialize invoices into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void PaymentManagementService::saveInvoices()
+{
+    util::FileManager<Invoice> invoiceFileManager(config::file::INVOICE_FILE);
+    auto& invoices = m_dataStore.getInvoices();
+    invoiceFileManager.save(invoices);
+}
+
+/*
+Function: loadObservers
+Description: Loads observer IDs from persistent storage and attaches corresponding
+             users as observers to the PaymentManagementService.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if an observer ID is invalid (not found in datastore)
+*/
+void PaymentManagementService::loadObservers()
+{
+    util::loadObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this, m_dataStore);
+}
+
+/*
+Function: saveObservers
+Description: Saves the current observer IDs of the PaymentManagementService
+             to persistent storage for future retrieval.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void PaymentManagementService::saveObservers()
+{
+    util::saveObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this);
+}
+
+/*
+Function: createInventoryItemsMap (static helper)
+Description: Builds a map of inventory items required for a given service and adds them to the booking’s inventory map.
+Parameters:
+	- completeInventoryItemMapOfBooking: util::Map<std::string, InventoryItem*>&, map to store inventory items for the booking
+	- currentService: const Service*, pointer to the current service
+Returns:
+	- void
+*/
+static void createInventoryItemsMap(util::Map<std::string, InventoryItem*>& completeInventoryItemMapOfBooking, const Service* currentService)
+{
+	auto& currentRequiredInventoryItems = currentService->getRequiredInventoryItems();
+	for (int iterator = 0; iterator < currentRequiredInventoryItems.getSize(); iterator++)
+	{
+		auto& currentRequiredInventoryItem = currentRequiredInventoryItems.getValueAt(iterator);
+		completeInventoryItemMapOfBooking.insert(currentRequiredInventoryItem->getId(), currentRequiredInventoryItem);
+	}
+}
+
+/*
+Function: generateInvoice
+Description: Generates an invoice for a completed service booking.
+			 Validates that all job cards are completed, calculates labor and parts cost, applies discount,
+			 and stores the invoice in the datastore.
+Parameters:
+	- booking: ServiceBooking*, pointer to the service booking
+Returns:
+	- void
+Throws:
+	- std::runtime_error if booking is null or job cards are incomplete
+*/
+void PaymentManagementService::generateInvoice(ServiceBooking* booking)
+{
+	if (!booking)
+	{
+		throw std::runtime_error("Invoice generation failed: booking is null.");
+	}
+	double totalLaborCost = 0, totalPartsCost = 0, totalServiceCost = 0;
+	double discountPercentage = booking->getDiscountPercentage();
+	std::string bookingID = booking->getId();
+	util::Map<std::string, Service*> servicesInTheBookedService = booking->getServices();
+	util::Map<std::string, InventoryItem*> completeInventoryItemMapOfBooking;
+	util::Map<std::string, JobCard*> currentJobCards = m_dataStore.getJobCards();
+	for (int iterator = 0; iterator < currentJobCards.getSize(); iterator++)
+	{
+		JobCard* currentJobCard = currentJobCards.getValueAt(iterator);
+		util::ServiceJobStatus currentJobCardStatus = currentJobCard->getStatus();
+		if (currentJobCard->getBookingId() == bookingID && currentJobCardStatus != util::ServiceJobStatus::CANCELLED && currentJobCardStatus != util::ServiceJobStatus::COMPLETED)
+		{
+			throw std::runtime_error("Invoice generation failed: Not all job cards are completed for booking '" + bookingID + "'.");
+		}
+	}
+	for (int iterator = 0; iterator < servicesInTheBookedService.getSize(); iterator++)
+	{
+		Service* currentService = servicesInTheBookedService.getValueAt(iterator);
+		if (currentService)
+		{
+			createInventoryItemsMap(completeInventoryItemMapOfBooking, currentService);
+			totalLaborCost += currentService->getLaborCost();
+			totalPartsCost += util::calculatePartsCost(currentService);
+		}
+	}
+	totalServiceCost = totalLaborCost + totalPartsCost;
+	totalServiceCost -= (totalServiceCost * (discountPercentage / 100));
+	Invoice* invoice = Factory::getObject<Invoice>(bookingID, booking, util::Timestamp(), totalLaborCost, completeInventoryItemMapOfBooking, totalPartsCost, discountPercentage, totalServiceCost, util::Timestamp(), util::PaymentMode::NOTSET, util::PaymentStatus::PENDING);
+	util::Map<std::string, Invoice*>& currentInvoices = m_dataStore.getInvoices();
+	currentInvoices.insert(invoice->getId(), invoice);
+}
+
+/*
+Function: getInvoices
+Description: Retrieves all invoices associated with a specific customer.
+Parameters:
+	- customerID: std::string, ID of the customer
+Returns:
+	- util::Map<std::string, Invoice*> containing the customer’s invoices
+*/
+util::Map<std::string, Invoice*> PaymentManagementService::getInvoices(const std::string& customerID)
+{
+	util::Map<std::string, Invoice*>& currentInvoices = m_dataStore.getInvoices();
+	util::Map<std::string, Invoice*> currentUserInvoices;
+	for (int iterator = 0; iterator < currentInvoices.getSize(); iterator++)
+	{
+		Invoice* currentInvoice = currentInvoices.getValueAt(iterator);
+		if (currentInvoice->getBooking()->getCustomerId() == customerID)
+		{
+			currentUserInvoices.insert(currentInvoice->getId(), currentInvoice);
+		}
+	}
+	return currentUserInvoices;
+}
+
+/*
+Function: completePayment
+Description: Completes payment for a specific invoice. Updates payment method, date, and status,
+			 then sends a notification to the customer.
+Parameters:
+	- invoiceID: std::string, ID of the invoice
+	- paymentMode: util::PaymentMode, mode of payment (e.g., ONLINE, OFFLINE)
+Returns:
+	- void
+Throws:
+	- std::runtime_error if the invoice ID is invalid
+*/
+void PaymentManagementService::completePayment(const std::string& invoiceID, util::PaymentMode paymentMode)
+{
+	auto& currentInvoices = m_dataStore.getInvoices();
+	int invoiceIndex = currentInvoices.find(invoiceID);
+	if (invoiceIndex != -1)
+	{
+		Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
+		if (invoice && invoice->getStatus() != util::PaymentStatus::PAID)
+		{
+			User* currentUser = invoice->getBooking()->getCustomer();
+			invoice->setPaymentMethod(paymentMode);
+			invoice->setPaymentDate(util::Timestamp());
+			invoice->setStatus(util::PaymentStatus::PAID);
+			std::string title, message;
+			title = "Payment successful";
+			message = "Payment successful for Invoice ID " + invoiceID;
+			sendNotification(currentUser, title, message);
+		}
+	}
+	else
+	{
+		throw std::runtime_error("Payment failed: invalid invoice ID.");
+	}
+}
+
+/*
+Function: getAllInvoice
+Description: Provides access to all invoices stored in the data store.
+Parameters:
+	- none
+Returns:
+	- util::Map<std::string, Invoice*>&: Map of invoice IDs to invoice objects
+*/
+util::Map<std::string, Invoice*>& PaymentManagementService::getAllInvoices()
+{
+	return m_dataStore.getInvoices();
+}
+
+/*
+Function: confirmPayment
+Description: Confirms payment for a specific invoice. Updates payment date and status,
+			 then sends a notification to the customer.
+Parameters:
+	- invoiceID: std::string, ID of the invoice to confirm
+Returns:
+	- void
+Throws:
+	- std::runtime_error if the invoice ID is invalid
+*/
+void PaymentManagementService::confirmPayment(const std::string& invoiceID)
+{
+	auto& currentInvoices = m_dataStore.getInvoices();
+	int invoiceIndex = currentInvoices.find(invoiceID);
+	if (invoiceIndex == -1)
+	{
+		throw std::runtime_error("Payment confirmation failed: invalid invoice ID.");
+	}
+	Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
+	if (!invoice || invoice->getStatus() != util::PaymentStatus::PAID)
+	{
+		throw std::runtime_error("Payment confirmation failed: invoice is not awaiting confirmation.");
+	}
+	User* currentUser = invoice->getBooking()->getCustomer();
+	invoice->setStatus(util::PaymentStatus::COMPLETED);
+	std::string title = "Payment Confirmed";
+	std::string message = "Payment Confirmed for Invoice ID " + invoiceID;
+	sendNotification(currentUser, title, message);
+}

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"
@@ -13,13 +22,20 @@ class PaymentManagementService : public NotificationManagementService
 private:
     DataStore& m_dataStore;
     static util::Map<std::string, User*> m_observers;
+    util::Vector<std::string> getObserverIDs() override;
 public:
     PaymentManagementService() : m_dataStore(DataStore::getInstance()) {}
     void generateInvoice(ServiceBooking* booking);
     util::Map<std::string, Invoice*> getInvoices(const std::string& customerID);
     void completePayment(const std::string& invoiceID, util::PaymentMode paymentMode);
+    util::Map<std::string, Invoice*>& getAllInvoices();
+    void confirmPayment(const std::string& invoiceID);
     void sendPaymentReminders();
     void sendNotification(User* user, const std::string& title, const std::string& message) override;
     void attach(User* user) override;
     void detach(User* user) override;
+    void loadInvoices();
+    void saveInvoices();
+    void loadObservers();
+    void saveObservers();
 };

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

@@ -1,16 +1,807 @@
-#include "ServiceManagementService.h"
-#include "UserManagementService.h"
-#include "ServiceBooking.h"
-#include "Factory.h"
-#include "JobCard.h"
-#include "Timestamp.h"
-#include "Service.h"
-#include "Enums.h"
-#include "InventoryItem.h"
+/*
+File: ServiceManagementService.cpp
+Description: Implementation file containing the method definitions of the
+			 ServiceManagementService class, including service and combo package
+			 purchasing logic, booking creation, and notification handling.
+Author: Trenser
+Date:19-May-2026
+*/
+
+#include <stdexcept>
 #include "AuthenticationManagementService.h"
-#include "PaymentManagementService.h"
+#include "ComboPackage.h"
+#include "Config.h"
+#include "DataStore.h"
+#include "Enums.h"
+#include "Factory.h"
+#include "FileManager.h"
+#include "InventoryItem.h"
+#include "JobCard.h"
 #include "NotificationManagementService.h"
+#include "PaymentManagementService.h"
+#include "Service.h"
+#include "ServiceBooking.h"
+#include "ServiceManagementService.h"
+#include "Timestamp.h"
 #include "User.h"
+#include "UserManagementService.h"
+#include "Utility.h"
+
+/*
+Function: purchaseService
+Description: Creates a new service booking for the authenticated user. Validates
+			 service IDs, retrieves services from the DataStore, and generates a
+			 booking. Sends a notification upon successful booking.
+Parameter: const util::Vector<std::string>& serviceIDs - IDs of services to purchase
+		   const std::string& vehicleNumber - vehicle registration number
+		   const std::string& vehicleBrand - brand of the vehicle
+		   const std::string& vehicleModel - model of the vehicle
+Return type: void
+*/
+void ServiceManagementService::purchaseService(const util::Vector<std::string>& serviceIDs, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
+{
+	AuthenticationManagementService m_authenticationManagementService;
+	auto authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
+	if (authenticatedUser == nullptr)
+	{
+		throw std::runtime_error("No user is currently logged in!");
+	}
+	auto& servicesMap = m_dataStore.getServices();
+	auto& serviceBookingMap = m_dataStore.getServiceBookings();
+	util::Map<std::string, Service*> selectedServices;
+	int selectedServicesCount = serviceIDs.getSize();
+	for (int index = 0; index < selectedServicesCount; index++)
+	{
+		int serviceIndex = servicesMap.find(serviceIDs[index]);
+		if (serviceIndex == -1)
+		{
+			throw std::runtime_error("Service not found!");
+		}
+		Service* service = servicesMap.getValueAt(serviceIndex);
+		selectedServices[service->getId()] = service;
+	}
+	ServiceBooking* serviceBooking = Factory::getObject<ServiceBooking>(util::ServiceJobStatus::PENDING, selectedServices, authenticatedUser->getId(), authenticatedUser, vehicleNumber, vehicleBrand, vehicleModel, 0);
+	if (serviceBooking == nullptr)
+	{
+		throw std::runtime_error("Failed to create service booking");
+	}
+	serviceBookingMap[serviceBooking->getId()] = serviceBooking;
+    std::string title = "Service Booking succeeded";
+    std::string message = "Your service booking has been successfully placed with ID " + serviceBooking->getId();
+    sendNotification(authenticatedUser, title, message);
+}
+
+/*
+Function: purchaseComboPackage
+Description: Creates a new service booking for a combo package. Validates the combo
+			 package ID, retrieves services from the package, and generates a booking
+			 with the applicable discount. Sends a notification upon successful booking.
+Parameter: const std::string& comboPackageID - ID of the combo package
+		   const std::string& vehicleNumber - vehicle registration number
+		   const std::string& vehicleBrand - brand of the vehicle
+		   const std::string& vehicleModel - model of the vehicle
+Return type: void
+*/
+void ServiceManagementService::purchaseComboPackage(const std::string& comboPackageID, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
+{
+	AuthenticationManagementService m_authenticationManagementService;
+	auto authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
+	if (authenticatedUser == nullptr)
+	{
+		throw std::runtime_error("No user is currently logged in!");
+	}
+	auto& comboPackagesMap = m_dataStore.getComboPackages();
+	auto& serviceBookingMap = m_dataStore.getServiceBookings();
+	int comboPackageIndex = comboPackagesMap.find(comboPackageID);
+	if (comboPackageIndex == -1)
+	{
+		throw std::runtime_error("Combo Package not found!");
+	}
+	const ComboPackage* comboPackage = comboPackagesMap[comboPackageID];
+	util::Map<std::string, Service*> selectedServices = comboPackage->getServices();
+	ServiceBooking* serviceBooking = Factory::getObject<ServiceBooking>(util::ServiceJobStatus::PENDING, selectedServices, authenticatedUser->getId(), authenticatedUser, vehicleNumber, vehicleBrand, vehicleModel, comboPackage->getDiscountPercentage());
+	if (serviceBooking == nullptr)
+	{
+		throw std::runtime_error("Failed to create combo package service booking");
+	}
+	serviceBookingMap[serviceBooking->getId()] = serviceBooking;
+    std::string title = "Combo Package Service Booking succeeded";
+    std::string message = "Your service booking for the combo package has been successfully placed with ID " + serviceBooking->getId();
+    sendNotification(authenticatedUser, title, message);
+}
+
+util::Map<std::string, User*> ServiceManagementService::m_observers{};
+
+/*
+Function: attach
+Description: Attaches a user as an observer to the ServiceManagementService for receiving notifications.
+Parameters:
+	- user: Pointer to the User object to be attached.
+Returns:
+	- void
+*/
+void ServiceManagementService::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 ServiceManagementService.
+Parameters:
+	- user: Pointer to the User object to be detached.
+Returns:
+	- void
+*/
+void ServiceManagementService::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 ServiceManagementService::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,
+					title,
+					message,
+					util::Timestamp()
+				);
+			if (notification)
+			{
+				user->addNotification(notification);
+			}
+			else
+			{
+				throw std::runtime_error("Failed to create notification");
+			}
+		}
+	}
+}
+
+/*
+Function: getObserverIDs
+Description: Retrieves the IDs of all observers currently attached to the
+             ServiceManagementService.
+Parameters:
+    - None
+Returns:
+    - util::Vector<std::string>: Vector of observer user IDs
+*/
+util::Vector<std::string> ServiceManagementService::getObserverIDs()
+{
+	util::Vector<std::string> observerIDs;
+	int numberOfObservers = m_observers.getSize();
+	for (int index = 0; index < numberOfObservers; index++)
+	{
+		User* observer = m_observers.getValueAt(index);
+		if (observer)
+		{
+			observerIDs.push_back(observer->getId());
+		}
+	}
+	return observerIDs;
+}
+
+/*
+Function: loadServices
+Description: Loads services from persistent storage into the datastore.
+             Validates required inventory items and attaches them to each service.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if an inventory item ID is invalid
+*/
+void ServiceManagementService::loadServices()
+{
+    util::FileManager<Service> serviceFileManager(config::file::SERVICE_FILE);
+    auto& services = m_dataStore.getServices();
+    auto& inventoryItems = m_dataStore.getInventoryItems();
+    auto servicesMap = serviceFileManager.load();
+    for (int serviceIndex = 0; serviceIndex < servicesMap.getSize(); serviceIndex++)
+    {
+        Service* service = servicesMap.getValueAt(serviceIndex);
+        services[service->getId()] = service;
+        util::Map<std::string, InventoryItem*> inventoryItemsMap;
+        auto& inventoryItemIDs = service->getRequiredInventoryItemIDs();
+        for (int inventoryItemIndex = 0; inventoryItemIndex < inventoryItemIDs.getSize(); inventoryItemIndex++)
+        {
+            const std::string& inventoryItemID = inventoryItemIDs[inventoryItemIndex];
+            int index = inventoryItems.find(inventoryItemID);
+            if (index == -1)
+            {
+                throw std::runtime_error("Invalid Inventory Item ID");
+            }
+            inventoryItemsMap[inventoryItemID] = inventoryItems.getValueAt(index);
+        }
+        service->setRequiredInventoryItems(inventoryItemsMap);
+    }
+}
+
+/*
+Function: saveServices
+Description: Saves services from the datastore to persistent storage.
+             Uses FileManager to serialize services into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void ServiceManagementService::saveServices()
+{
+	util::FileManager<Service> serviceFileManager(config::file::SERVICE_FILE);
+	auto& services = m_dataStore.getServices();
+	serviceFileManager.save(services);
+}
+
+/*
+Function: loadComboPackages
+Description: Loads combo packages from persistent storage into the datastore.
+             Validates associated services and attaches them to each package.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a service ID is invalid
+*/
+void ServiceManagementService::loadComboPackages()
+{
+    util::FileManager<ComboPackage> comboPackageFileManager(config::file::COMBOPACKAGE_FILE);
+    auto& comboPackages = m_dataStore.getComboPackages();
+    auto& services = m_dataStore.getServices();
+    auto comboPackagesMap = comboPackageFileManager.load();
+    for (int packageIndex = 0; packageIndex < comboPackagesMap.getSize(); packageIndex++)
+    {
+        ComboPackage* comboPackage = comboPackagesMap.getValueAt(packageIndex);
+        util::Map<std::string, Service*> packageServices;
+        auto& serviceIDs = comboPackage->getServiceIDs();
+        for (int serviceIndex = 0; serviceIndex < serviceIDs.getSize(); serviceIndex++)
+        {
+            const std::string& serviceID = serviceIDs[serviceIndex];
+            int serviceMapIndex = services.find(serviceID);
+            if (serviceMapIndex == -1)
+            {
+                throw std::runtime_error("Invalid Service ID");
+            }
+            packageServices[serviceID] = services.getValueAt(serviceMapIndex);
+        }
+        comboPackage->setServices(packageServices);
+        comboPackages[comboPackage->getId()] = comboPackage;
+    }
+}
+
+/*
+Function: saveComboPackages
+Description: Saves combo packages from the datastore to persistent storage.
+             Uses FileManager to serialize combo packages into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void ServiceManagementService::saveComboPackages()
+{
+    util::FileManager<ComboPackage> comboPackageFileManager(config::file::COMBOPACKAGE_FILE);
+    auto& comboPackages = m_dataStore.getComboPackages();
+    comboPackageFileManager.save(comboPackages);
+}
+
+/*
+Function: loadServiceBookings
+Description: Loads service bookings from persistent storage into the datastore.
+             Validates associated services, customers, and technicians before
+             attaching them to each booking.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a service ID, customer ID, or technician ID is invalid
+    - std::runtime_error if a user is not of the expected type (customer/technician)
+*/
+void ServiceManagementService::loadServiceBookings()
+{
+    util::FileManager<ServiceBooking> bookingFileManager(config::file::SERVICEBOOKING_FILE);
+    auto& serviceBookings = m_dataStore.getServiceBookings();
+    auto& services = m_dataStore.getServices();
+    auto& users = m_dataStore.getUsers();
+    auto bookingsMap = bookingFileManager.load();
+    for (int bookingIndex = 0; bookingIndex < bookingsMap.getSize(); bookingIndex++)
+    {
+        ServiceBooking* booking = bookingsMap.getValueAt(bookingIndex);
+        util::Map<std::string, Service*> bookingServices;
+        auto& serviceIDs = booking->getServiceIDs();
+        for (int serviceIndex = 0; serviceIndex < serviceIDs.getSize(); serviceIndex++)
+        {
+            const std::string& serviceID = serviceIDs[serviceIndex];
+            int serviceMapIndex = services.find(serviceID);
+            if (serviceMapIndex == -1)
+            {
+                throw std::runtime_error("Invalid Service ID");
+            }
+
+            bookingServices[serviceID] = services.getValueAt(serviceMapIndex);
+        }
+        booking->setServices(bookingServices);
+        int customerIndex = users.find(booking->getCustomerId());
+        if (customerIndex == -1)
+        {
+            throw std::runtime_error("Invalid Customer ID");
+        }
+        User* customer = users.getValueAt(customerIndex);
+        if (customer->getUserType() != util::UserType::CUSTOMER)
+        {
+            throw std::runtime_error("User is not a customer");
+        }
+        booking->setCustomer(customer);
+        const std::string& technicianId = booking->getAssignedTechnicianId();
+        if (!technicianId.empty())
+        {
+            int technicianIndex = users.find(technicianId);
+            if (technicianIndex == -1)
+            {
+                throw std::runtime_error("Invalid Technician ID");
+            }
+            User* technician = users.getValueAt(technicianIndex);
+            if (technician->getUserType() != util::UserType::TECHNICIAN)
+            {
+                throw std::runtime_error("User is not a technician");
+            }
+            booking->setAssignedTechnician(technician);
+        }
+        serviceBookings[booking->getId()] = booking;
+    }
+}
+
+/*
+Function: saveServiceBookings
+Description: Saves service bookings from the datastore to persistent storage.
+             Uses FileManager to serialize bookings into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void ServiceManagementService::saveServiceBookings()
+{
+    util::FileManager<ServiceBooking> bookingFileManager(config::file::SERVICEBOOKING_FILE);
+    auto& serviceBookings = m_dataStore.getServiceBookings();
+    bookingFileManager.save(serviceBookings);
+}
+
+/*
+Function: loadJobCards
+Description: Loads job cards from persistent storage into the datastore.
+             Validates associated bookings, services, and technicians before
+             attaching them to each job card.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a booking ID, service ID, or technician ID is invalid
+    - std::runtime_error if a service does not belong to the booking
+    - std::runtime_error if a user is not a technician
+*/
+void ServiceManagementService::loadJobCards()
+{
+    util::FileManager<JobCard> jobCardFileManager(config::file::JOBCARD_FILE);
+    auto& jobCards = m_dataStore.getJobCards();
+    auto& serviceBookings = m_dataStore.getServiceBookings();
+    auto& services = m_dataStore.getServices();
+    auto& users = m_dataStore.getUsers();
+    auto jobCardsMap = jobCardFileManager.load();
+    for (int jobCardIndex = 0; jobCardIndex < jobCardsMap.getSize(); jobCardIndex++)
+    {
+        JobCard* jobCard = jobCardsMap.getValueAt(jobCardIndex);
+        int bookingIndex = serviceBookings.find(jobCard->getBookingId());
+        if (bookingIndex == -1)
+        {
+            throw std::runtime_error("Invalid Booking ID");
+        }
+        ServiceBooking* booking = serviceBookings.getValueAt(bookingIndex);
+        jobCard->setBooking(booking);
+        int serviceIndex = services.find(jobCard->getServiceId());
+        if (serviceIndex == -1)
+        {
+            throw std::runtime_error("Invalid Service ID");
+        }
+        Service* service = services.getValueAt(serviceIndex);
+        if (booking->getServices().find(jobCard->getServiceId()) == -1)
+        {
+            throw std::runtime_error("Service does not belong to booking");
+        }
+        jobCard->setService(service);
+        int technicianIndex = users.find(jobCard->getTechnicianId());
+        if (technicianIndex == -1)
+        {
+            throw std::runtime_error("Invalid Technician ID");
+        }
+        User* technician = users.getValueAt(technicianIndex);
+        if (technician->getUserType() != util::UserType::TECHNICIAN)
+        {
+            throw std::runtime_error("User is not a technician");
+        }
+        jobCard->setTechnician(technician);
+        jobCards[jobCard->getId()] = jobCard;
+    }
+}
+
+/*
+Function: saveJobCards
+Description: Saves job cards from the datastore to persistent storage.
+             Uses FileManager to serialize job cards into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void ServiceManagementService::saveJobCards()
+{
+    util::FileManager<JobCard> jobCardFileManager(config::file::JOBCARD_FILE);
+    auto& jobCards = m_dataStore.getJobCards();
+    jobCardFileManager.save(jobCards);
+}
+
+/*
+Function: loadObservers
+Description: Loads observer IDs from persistent storage and attaches corresponding
+             users as observers to the ServiceManagementService.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if an observer ID is invalid (not found in datastore)
+*/
+void ServiceManagementService::loadObservers()
+{
+    util::loadObservers(config::file::SERVICEMANAGEMENTOBSERVERS, this, m_dataStore);
+}
+
+/*
+Function: saveObservers
+Description: Saves the current observer IDs of the ServiceManagementService
+             to persistent storage for future retrieval.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void ServiceManagementService::saveObservers()
+{
+    util::saveObservers(config::file::SERVICEMANAGEMENTOBSERVERS, this);
+}
+
+/*
+Function: restoreInventory
+Description: Restores inventory quantities for all required items in the services associated
+             with a given booking. Each item's quantity is incremented by a fixed value.
+Parameter: ServiceBooking* booking - Pointer to the booking whose inventory items need to be restored
+Return type: void
+*/
+static void restoreInventory(ServiceBooking* booking)
+{
+    const int INCREMENT_VALUE = 1;
+    if (!booking) 
+    {
+        return;
+    }
+    const auto& services = booking->getServices();
+    for (int serviceIterator = 0; serviceIterator < services.getSize(); ++serviceIterator)
+    {
+        Service* service = services.getValueAt(serviceIterator);
+        if (!service) 
+        {
+            continue;
+        }
+        const auto& items = service->getRequiredInventoryItems();
+        for (int InventoryIterator = 0; InventoryIterator < items.getSize(); ++InventoryIterator)
+        {
+            InventoryItem* item = items.getValueAt(InventoryIterator);
+            if (item)
+            {
+                item->setQuantity(item->getQuantity() + INCREMENT_VALUE);
+            }
+        }
+    }
+}
+
+/*
+Function: processBookingCancellation
+Description: Cancels jobs and updates the status of a given booking. Sends notifications to the
+             specified user, resets technician assignment if needed, and restores inventory items.
+Parameter: ServiceBooking* booking - Pointer to the booking being cancelled
+           util::ServiceJobStatus newServiceBookingStatus - New status to assign to the booking
+           const std::string& notificationTitle - Title of the booking cancellation notification
+           const std::string& notificationMessage - Message body of the booking cancellation notification
+           User* notifyUser - User to notify about the cancellation
+           util::ServiceJobStatus jobCardStatus - New status to assign to associated job cards
+           const std::string& jobNotificationTitle - Title of the job cancellation notification
+           const std::string& jobNotificationMessage - Message body of the job cancellation notification
+           util::Map<std::string, JobCard*>& jobs - Collection of job cards to update
+           ServiceManagementService& currentService - Reference to the service for sending notifications
+Return type: void
+*/
+static void processBookingCancellation(ServiceBooking* booking,
+    util::ServiceJobStatus newServiceBookingStatus,
+    const std::string& notificationTitle,
+    const std::string& notificationMessage,
+    User* notifyUser,
+    util::ServiceJobStatus jobCardStatus,
+    const std::string& jobNotificationTitle,
+    const std::string& jobNotificationMessage,
+    util::Map<std::string, JobCard*>& jobs, ServiceManagementService& currentService)
+{
+    if (!booking || !notifyUser)
+    {
+        return;
+    }
+    for (int jobIterator = 0; jobIterator < jobs.getSize(); ++jobIterator)
+    {
+        JobCard* jobCard = jobs.getValueAt(jobIterator);
+        if (jobCard && jobCard->getBookingId() == booking->getId())
+        {
+            jobCard->setStatus(jobCardStatus);
+            currentService.sendNotification(notifyUser, jobNotificationTitle, jobNotificationMessage);
+        }
+    }
+    booking->setStatus(newServiceBookingStatus);
+    currentService.sendNotification(notifyUser, notificationTitle, notificationMessage);
+    if (newServiceBookingStatus == util::ServiceJobStatus::PENDING)
+    {
+        booking->setAssignedTechnician(nullptr);
+        booking->setAssignedTechnicianId("");
+    }
+    restoreInventory(booking);
+}
+
+/*
+Function: cancelCustomerServiceBookings
+Description: Cancels all service bookings associated with a given customer or technician.
+             Updates booking status, resets customer/technician assignments, sends notifications,
+             and restocks inventory items.
+Parameter: const std::string& userID - ID of the customer or technician
+Return type: void
+*/
+void ServiceManagementService::cancelCustomerServiceBookings(const std::string& customerID)
+{
+    auto& users = m_dataStore.getUsers();
+    int userIndex = users.find(customerID);
+    if (userIndex == -1)
+    {
+        throw std::runtime_error("User not found: " + customerID);
+    }
+    User* customer = users.getValueAt(userIndex);
+    if (!customer)
+    {
+        throw std::runtime_error("User not found: " + customerID);
+    }
+    auto& bookings = m_dataStore.getServiceBookings();
+    auto& jobs = m_dataStore.getJobCards();
+    for (int iteratorOne = 0; iteratorOne < bookings.getSize(); iteratorOne++)
+    {
+        ServiceBooking* booking = bookings.getValueAt(iteratorOne);
+        if (!booking)
+        {
+            continue;
+        }
+        if (booking->getCustomerId() != customerID)
+        {
+            continue;
+        }
+        if (booking->getStatus() != util::ServiceJobStatus::PENDING && booking->getStatus() != util::ServiceJobStatus::STARTED)
+        {
+            continue;
+        }
+        User* assignedTechnician = booking->getAssignedTechnician();
+        std::string titleToTechnician = "Customer Service Cancelled";
+        std::string messageToTechnician = "The customer has cancelled their service booking. Your assigned job card has been cancelled and the inventory has been restocked.";
+        std::string jobTitle = "Job Cancelled";
+        std::string jobMessage = "The job has been cancelled. Your job card has been cancelled and the inventory has been restocked.";
+        processBookingCancellation(booking, 
+            util::ServiceJobStatus::CANCELLED,
+            titleToTechnician, messageToTechnician, assignedTechnician,
+            util::ServiceJobStatus::CANCELLED,
+            jobTitle, jobMessage, jobs, *this
+        );
+    }
+}
+
+/*
+Function: cancelTechnicianJobs
+Description: Cancels all jobs assigned to a technician. Updates job status, sends notifications,
+             and restocks inventory items used in the service.
+Parameter: const std::string& technicianID - ID of the technician
+Return type: void
+*/
+void ServiceManagementService::cancelTechnicianJobs(const std::string& technicianID)
+{
+    auto& users = m_dataStore.getUsers();
+    int userIndex = users.find(technicianID);
+    if (userIndex == -1)
+    {
+        throw std::runtime_error("User not found: " + technicianID);
+    }
+    User* technician = users.getValueAt(userIndex);
+    if (!technician)
+    {
+        throw std::runtime_error("User not found: " + technicianID);
+    }
+    auto& bookings = m_dataStore.getServiceBookings();
+    auto& jobs = m_dataStore.getJobCards();
+    for (int iteratorOne = 0; iteratorOne < bookings.getSize(); iteratorOne++)
+    {
+        ServiceBooking* booking = bookings.getValueAt(iteratorOne);
+        if (!booking)
+        {
+            continue;
+        }
+        std::string technicianId = booking->getAssignedTechnicianId();
+        if (technicianId != technicianID)
+        {
+            continue;
+        }
+        if (booking->getStatus() != util::ServiceJobStatus::PENDING && booking->getStatus() != util::ServiceJobStatus::STARTED)
+        {
+            continue;
+        }
+        User* customer = booking->getCustomer();
+        if (!customer)
+        {
+            continue;
+        }
+        std::string title = "Technician Unavailable";
+        std::string message = "Your assigned technician is no longer available. Your booking has been reset to pending and we will reassign a new technician shortly.";
+        processBookingCancellation(booking,
+            util::ServiceJobStatus::PENDING,
+            title, message, customer,
+            util::ServiceJobStatus::CANCELLED,
+            title, message, jobs, *this
+        );
+    }
+}
+
+/*
+Function: createComboPackage
+Description: Creates a new combo package with two services and a discount percentage.
+             Validates service IDs, ensures uniqueness, and inserts the new package into the DataStore.
+Parameter: const std::string& packageName - name of the combo package
+           const util::Vector<std::string>& serviceIDsInNewCombo - list of service IDs
+           double discountPercentage - discount percentage for the package
+Return type: void
+*/
+void ServiceManagementService::createComboPackage(const std::string& packageName, const util::Vector<std::string>& serviceIDsInNewCombo, double discountPercentage)
+{
+    if (packageName.empty())
+    {
+        throw std::invalid_argument("The Combo Package Name cannot be empty.\n");
+    }
+    if (serviceIDsInNewCombo.getSize() < 2 || serviceIDsInNewCombo.getSize() > 2)
+    {
+        throw std::invalid_argument("Combo package must contain only two services.");
+    }
+    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.");
+    }
+}
 
 /*
 Function: getServiceBookings
@@ -83,12 +874,16 @@ void ServiceManagementService::createJobCard(const std::string& bookingID, const
 	for (int iterator = 0; iterator < inventoryItems.getSize(); iterator++)
 	{
 		InventoryItem* currentInventoryItem = inventoryItems.getValueAt(iterator);
-		if (currentInventoryItem->getQuantity() == 0)
+		if (currentInventoryItem && currentInventoryItem->getQuantity() == 0)
 		{
 			std::string errorMessage = "Failed to create job card, " + currentInventoryItem->getPartName() + " is out of stock.";
 			throw std::runtime_error(errorMessage);
 		}
-		else
+	}
+	for (int iterator = 0; iterator < inventoryItems.getSize(); iterator++)
+	{
+		InventoryItem* currentInventoryItem = inventoryItems.getValueAt(iterator);
+		if (currentInventoryItem)
 		{
 			int currentStockQuantity = currentInventoryItem->getQuantity();
 			currentInventoryItem->setQuantity(currentStockQuantity - 1);
@@ -96,11 +891,25 @@ void ServiceManagementService::createJobCard(const std::string& bookingID, const
 	}
 	currentBooking->setAssignedTechnician(selectedTechnician);
 	currentBooking->setAssignedTechnicianId(selectedTechnician->getId());
+    if (currentBooking->getStatus() == util::ServiceJobStatus::PENDING)
+    {
+        currentBooking->setStatus(util::ServiceJobStatus::STARTED);
+    }
 	std::string title = "Job card created";
 	std::string message = "Job card created for the service and you are assigned for that.";
 	JobCard* jobCard = Factory::getObject<JobCard>(bookingID, currentBooking, currentService, serviceID, technicianID, selectedTechnician, util::Timestamp(), util::ServiceJobStatus::STARTED, util::Timestamp());
-	currentJobCards.insert(jobCard->getId(), jobCard);
-	sendNotification(selectedTechnician,title, message);
+	if (jobCard)
+	{
+		currentJobCards.insert(jobCard->getId(), jobCard);
+		sendNotification(selectedTechnician, title, message);
+	}
+	else
+	{
+		throw std::runtime_error("Failed to create job card.");
+	}
+    title = "Technician assigned";
+    message = "A technician has been assigned to your Service Booking with ID " + bookingID;
+    sendNotification(currentBooking->getCustomer(), title, message);
 }
 
 /*
@@ -177,10 +986,28 @@ Throws:
 */
 void ServiceManagementService::removeService(const std::string& serviceID)
 {
-	util::Map<std::string, Service*> currentServices = getServices();
+	util::Map<std::string, Service*>& currentServices = m_dataStore.getServices();
+    util::Map<std::string, ComboPackage*>& currentComboPackages =  m_dataStore.getComboPackages();
 	if (currentServices.find(serviceID) != -1)
 	{
 		currentServices.getValueAt(currentServices.find(serviceID))->setState(util::State::INACTIVE);
+        for (int iterator = 0; iterator < currentComboPackages.getSize(); iterator++)
+        {
+            ComboPackage* currentComboPackage = currentComboPackages.getValueAt(iterator);
+            if (currentComboPackage && currentComboPackage->getState() == util::State::ACTIVE)
+            {
+                util::Map<std::string, Service*> currentServices = currentComboPackage->getServices();
+                for (int iterator = 0; iterator < currentServices.getSize(); iterator++)
+                {
+                    auto currentService = currentServices.getValueAt(iterator);
+                    if (currentService->getId() == serviceID)
+                    {
+                        currentComboPackage->setState(util::State::INACTIVE);
+                        break;
+                    }
+                }
+            }
+        }
 	}
 	else
 	{
@@ -238,7 +1065,7 @@ util::Map<std::string, JobCard*> ServiceManagementService::getJobCards(const std
 }
 
 /*
-Function: hasAllJobCardsinServiceBookingCompleted (static helper)
+Function: hasCompletedAllJobs (static helper)
 Description: Checks if all job cards for a given service booking are completed.
 Parameters:
 	- bookingId: std::string, ID of the service booking
@@ -246,14 +1073,14 @@ Parameters:
 Returns:
 	- bool: True if all job cards are completed, False otherwise
 */
-static bool hasAllJobCardsinServiceBookingCompleted(std::string bookingId, util::Map<std::string, JobCard*>& currentAssignedJobs)
+static bool hasCompletedAllJobs(std::string bookingId, util::Map<std::string, JobCard*>& currentAssignedJobs)
 {
 	for (int iterator = 0; iterator < currentAssignedJobs.getSize(); iterator++)
 	{
 		JobCard* currentJob = currentAssignedJobs.getValueAt(iterator);
 		if (currentJob->getBookingId() == bookingId)
 		{
-			if (currentJob->getStatus() == util::ServiceJobStatus::STARTED)
+			if (currentJob->getStatus() != util::ServiceJobStatus::COMPLETED && currentJob->getStatus() != util::ServiceJobStatus::CANCELLED)
 			{
 				return false;
 			}
@@ -263,18 +1090,19 @@ static bool hasAllJobCardsinServiceBookingCompleted(std::string bookingId, util:
 }
 
 /*
-Function: completeJob
-Description: Marks a job card as completed for the authenticated technician.
-			 If all job cards in the booking are completed, marks the booking as completed
-			 and generates an invoice.
+Function: updateJobStatus
+Description:
+    Updates the status of a job card assigned to the currently authenticated technician.
+    - If the job is STARTED, it moves to IN_PROGRESS.
+    - If the job is IN_PROGRESS, it moves to COMPLETED.
+    When all jobs in a service booking are completed, the booking status is updated,
+    an invoice is generated, and a notification is sent to the customer.
 Parameters:
-	- jobID: std::string, ID of the job card
+    - jobID: const std::string&, unique identifier of the job card to update.
 Returns:
-	- void
-Throws:
-	- std::runtime_error if technician is not authenticated, job card not found, or job already completed
+    - void
 */
-void ServiceManagementService::completeJob(const std::string& jobID)
+void ServiceManagementService::updateJobStatus(const std::string& jobID)
 {
 	AuthenticationManagementService authenticationManagementService;
 	PaymentManagementService paymentManagementService;
@@ -299,26 +1127,30 @@ void ServiceManagementService::completeJob(const std::string& jobID)
 		}
 		if (currentJob->getStatus() == util::ServiceJobStatus::STARTED)
 		{
-			currentJob->setStatus(util::ServiceJobStatus::COMPLETED);
+			currentJob->setStatus(util::ServiceJobStatus::IN_PROGRESS);
 			jobStatusUpdated = true;
 		}
+        else if (currentJob->getStatus() == util::ServiceJobStatus::IN_PROGRESS)
+        {
+            currentJob->setStatus(util::ServiceJobStatus::COMPLETED);
+            jobStatusUpdated = true;
+            serviceBookingCompleted = hasCompletedAllJobs(currentJob->getBookingId(), currentAssignedJobs);
+            if (serviceBookingCompleted)
+            {
+                currentJob->getBooking()->setStatus(util::ServiceJobStatus::COMPLETED);
+                paymentManagementService.generateInvoice(currentJob->getBooking());
+                std::string title = "Service Booking completed. Invoice Generated.";
+                std::string message = "Services completed for the booking and invoice generated.";
+                sendNotification(currentJob->getBooking()->getCustomer(), title, message);
+            }
+        }
 	}
 	else
 	{
-		throw std::runtime_error("Failed to complete the job, some error occured or job already completed.");
+		throw std::runtime_error("Failed to update job status. Job may already be completed.");
 	}
 	if (!jobStatusUpdated)
 	{
-		throw std::runtime_error("Failed to complete the job, some error occured or job already completed.");
-	}
-
-	serviceBookingCompleted = hasAllJobCardsinServiceBookingCompleted(currentJob->getBookingId(), currentAssignedJobs);
-	if (serviceBookingCompleted)
-	{
-		currentJob->getBooking()->setStatus(util::ServiceJobStatus::COMPLETED);
-		paymentManagementService.generateInvoice(currentJob->getBooking());
-		std::string title = "Service Booking completed,Invoice Generated.\n";
-		std::string message = "Services completed for the booking and invoice generated.\n";
-		sendNotification(currentJob->getBooking()->getCustomer(), title, message);
+		throw std::runtime_error("Failed to update job status. Job may already be completed.");
 	}
 }

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

@@ -1,3 +1,12 @@
+/*
+File: ServiceManagementService.h
+Description: Header file declaring the ServiceManagementService class, which manages
+             services, combo packages, job cards, and service bookings. Inherits from
+             NotificationManagementService to handle notifications.
+Author: Trenser
+Date:19-May-2026
+*/
+
 #pragma once
 #include <string>
 #include "Map.h"
@@ -14,6 +23,7 @@ class ServiceManagementService : public NotificationManagementService
 private:
     DataStore& m_dataStore;
     static util::Map<std::string, User*> m_observers;
+    util::Vector<std::string> getObserverIDs() override;
 public:
     ServiceManagementService() : m_dataStore(DataStore::getInstance()) {}
     util::Map<std::string, Service*> getServices();
@@ -27,12 +37,22 @@ public:
     void createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost);
     void removeService(const std::string& serviceID);
     util::Map<std::string, JobCard*> getJobCards(const std::string& technicianID);
-    void completeJob(const std::string& jobID);
+    void updateJobStatus(const std::string& jobID);
     void cancelCustomerServiceBookings(const std::string& customerID);
     void cancelTechnicianJobs(const std::string& technicianID);
-    void createComboPackage(const std::string& name, const util::Vector<std::string>& serviceIDs, double discountPercentage);
+    void createComboPackage(const std::string& packageName, 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;
     void detach(User* user) override;
+    void loadServices();
+    void saveServices();
+    void loadComboPackages();
+    void saveComboPackages();
+    void loadServiceBookings();
+    void saveServiceBookings();
+    void loadJobCards();
+    void saveJobCards();
+    void loadObservers();
+    void saveObservers();
 };

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

@@ -1,5 +1,326 @@
-#include "UserManagementService.h"
+/*
+File: UserManagementService.cpp
+Description: Implementation file containing the method definitions of the
+			 UserManagementService class, including user creation, updates,
+			 and ensuring an admin account exists.
+Author: Trenser
+Date:19-May-2026
+*/
+
+#include <stdexcept>
+#include "Config.h"
+#include "Enums.h"
+#include "Factory.h"
+#include "FileManager.h"
+#include "InventoryManagementService.h"
+#include "Notification.h"
+#include "PaymentManagementService.h"
+#include "ServiceManagementService.h"
 #include "User.h"
+#include "UserManagementService.h"
+#include "Vector.h"
+#include "Validator.h"
+
+/*
+Function: ensureAdminExists
+Description: Ensures that at least one admin user exists in the system.
+			 If no admin is found, creates a default admin user using
+			 configuration constants.
+Parameter: None
+Return type: void
+*/
+void UserManagementService::ensureAdminExists()
+{
+	auto& usersMap = m_dataStore.getUsers();
+	int usersMapSize = usersMap.getSize();
+	bool isAdminFound = false;
+	for (int index = 0; index < usersMapSize; index++)
+	{
+		User* user = usersMap.getValueAt(index);
+		if (user && user->getUserType() == util::UserType::ADMIN)
+		{
+			isAdminFound = true;
+			break;
+		}
+	}
+	if (!isAdminFound)
+	{
+		createUser(
+			config::admin::DEFAULT_ADMIN_USERNAME,
+			config::admin::DEFAULT_ADMIN_NAME,
+			config::admin::DEFAULT_ADMIN_PASSWORD,
+			config::admin::DEFAULT_ADMIN_EMAIL,
+			config::admin::DEFAULT_ADMIN_PHONE, 
+			util::UserType::ADMIN);
+	}
+}
+
+/*
+Function: createUser
+Description: Creates a new user with the provided details. Validates that
+			 the username is unique, then attaches the user to relevant
+			 management services (payment, service, inventory).
+Parameter: const std::string& username - user’s username
+		   const std::string& name - user’s name
+		   const std::string& password - user’s password
+		   const std::string& email - user’s email address
+		   const std::string& phone - user’s phone number
+		   util::UserType type - type of user (ADMIN, CUSTOMER, TECHNICIAN)
+Return type: void
+*/
+void UserManagementService::createUser(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone, util::UserType type)
+{
+	InventoryManagementService inventoryManagementService;
+	PaymentManagementService paymentManagementService;
+	ServiceManagementService serviceManagementService;
+	auto& usersMap = m_dataStore.getUsers();
+	if (util::isUsernameDuplicate(username, usersMap))
+	{
+		throw std::runtime_error("Username already exists");
+	}
+	if (util::isEmailDuplicate(email, usersMap))
+	{
+		throw std::runtime_error("Email already exists");
+	}
+	if (util::isPhoneDuplicate(phone, usersMap))
+	{
+		throw std::runtime_error("Phone already exists");
+	}
+	User* newUser = Factory::getObject<User>(username, password, name, phone, email, type);
+	usersMap.insert(newUser->getId(), newUser);
+	paymentManagementService.attach(newUser);
+	serviceManagementService.attach(newUser);
+	if (newUser->getUserType() == util::UserType::ADMIN)
+	{
+		inventoryManagementService.attach(newUser);
+	}
+}
+
+/*
+Function: updateUserDetails
+Description: Updates the email and phone details of an existing user.
+			 Throws an exception if the user does not exist.
+Parameter: const std::string& userID - ID of the user to update
+		   const std::string& email - new email address
+		   const std::string& phone - new phone number
+Return type: void
+*/
+void UserManagementService::updateUserDetails(const std::string& userID, const std::string& email, const std::string& phone)
+{
+	auto& usersMap = m_dataStore.getUsers();
+	int index = usersMap.find(userID);
+	if (index == -1)
+	{
+		throw std::runtime_error("User does not exist!\n");
+	}
+	User* user = usersMap.getValueAt(index);
+	if (email != user->getEmail())
+	{
+		if (util::isEmailDuplicate(email, usersMap))
+		{
+			throw std::runtime_error("Email already exists!\n");
+		}
+	}
+	if (phone != user->getPhone())
+	{
+		if (util::isPhoneDuplicate(phone, usersMap))
+		{
+			throw std::runtime_error("Phone number already exists!\n");
+		}
+	}
+	user->setEmail(email);
+	user->setPhone(phone);
+}
+
+/*
+Function: getUserNotifications
+Description: Retrieves all notifications associated with a given user ID.
+Parameters:
+	- userID: The unique ID of the user whose notifications are to be retrieved.
+Returns:
+	- util::Vector<Notification*> containing all notifications for the user.
+Throws:
+	- std::runtime_error if no user is found with the given UserID or if the User object is invalid.
+*/
+util::Vector<Notification*> UserManagementService::getUserNotifications(const std::string& userID)
+{
+	auto& usersMap = m_dataStore.getUsers();
+	if (usersMap.find(userID) == -1)
+	{
+		throw std::runtime_error("No user found with given UserID");
+	}
+	User* user = usersMap[userID];
+	if (user)
+	{
+		auto& notifications = user->getNotifications();
+		int numberOfNotifications = notifications.getSize();
+		util::Vector<Notification*> notificationsVector;
+		for (int index = 0; index < numberOfNotifications; index++)
+		{
+		    notificationsVector.push_back(notifications.getValueAt(index));
+		}
+		return notificationsVector;
+	}
+	else
+	{
+		throw std::runtime_error("Invalid User object");
+	}
+}
+
+/*
+Function: deleteNotification
+Description: Deletes a specific notification associated with a given user ID.
+Parameters:
+	- notificationID: The unique ID of the notification to be deleted.
+	- userID: The unique ID of the user whose notification is to be deleted.
+Returns:
+	- void
+Throws:
+	- std::runtime_error if no user is found with the given UserID or if no notification is found with the given NotificationID.
+*/
+void UserManagementService::deleteNotification(const std::string& notificationID, const std::string& userID)
+{
+	auto& usersMap = m_dataStore.getUsers();
+	if (usersMap.find(userID) == -1)
+	{
+		throw std::runtime_error("No user found with given UserID");
+	}
+	User* user = usersMap[userID];
+	auto& notifications = user->getNotifications();
+	if (notifications.find(notificationID) == -1)
+	{
+		throw std::runtime_error("No notification found with given NotificationID");
+	}
+	notifications.remove(notificationID);
+}
+
+/*
+Function: loadUsers
+Description: Loads users and notifications from persistent storage into the datastore.
+             Validates that each notification’s recipient exists and attaches the
+             notification to the corresponding user.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a notification recipient user ID is invalid
+*/
+void UserManagementService::loadUsers()
+{
+    util::FileManager<User> userFileManager(config::file::USER_FILE);
+    util::FileManager<Notification> notificationFileManager(config::file::NOTIFICATION_FILE);
+    auto& users = m_dataStore.getUsers();
+    auto usersMap = userFileManager.load();
+    auto notificationsMap = notificationFileManager.load();
+    int numberOfUsers = usersMap.getSize();
+    int numberOfNotifications = notificationsMap.getSize();
+    for (int index = 0; index < numberOfUsers; index++)
+    {
+        users[usersMap.getKeyAt(index)] = usersMap.getValueAt(index);
+    }
+    for (int index = 0; index < numberOfNotifications; index++)
+    {
+        Notification* notification = notificationsMap.getValueAt(index);
+        const std::string& recipientUserId = notification->getRecipientUserId();
+        int userIndex = users.find(recipientUserId);
+        if (userIndex == -1)
+        {
+            throw std::runtime_error("Invalid recipient user ID");
+        }
+        User* user = users.getValueAt(userIndex);
+        user->addNotification(notification);
+    }
+}
+
+/*
+Function: saveUsers
+Description: Saves users and their notifications from the datastore to persistent storage.
+             Collects notifications from all users into a single map before saving.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void UserManagementService::saveUsers()
+{
+    util::FileManager<User> userFileManager(config::file::USER_FILE);
+    util::FileManager<Notification> notificationFileManager(config::file::NOTIFICATION_FILE);
+    auto& users = m_dataStore.getUsers();
+    util::Map<std::string, Notification*> notifications;
+    for (int userIndex = 0; userIndex < users.getSize(); userIndex++)
+    {
+        User* user = users.getValueAt(userIndex);
+        auto& userNotifications = user->getNotifications();
+        for (int notificationIndex = 0; notificationIndex < userNotifications.getSize(); notificationIndex++)
+        {
+            notifications[userNotifications.getKeyAt(notificationIndex)] =
+                userNotifications.getValueAt(notificationIndex);
+        }
+    }
+    userFileManager.save(users);
+    notificationFileManager.save(notifications);
+}
+
+/*
+Function: getUsers
+Description: Retrieves all users stored in the DataStore.
+Parameter: None
+Return type: util::Map<std::string, User*>
+*/
+util::Map<std::string, User*> UserManagementService::getUsers()
+{
+	return m_dataStore.getUsers();
+}
+
+/*
+Function: getUser
+Description: Retrieves a specific user by ID from the DataStore.
+Parameter: const std::string& userID - ID of the user
+Return type: User*
+*/
+User* UserManagementService::getUser(const std::string& userID)
+{
+	int index = m_dataStore.getUsers().find(userID);
+	if (index != -1)
+	{
+		return m_dataStore.getUsers().getValueAt(index);
+	}
+	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)
+{
+	InventoryManagementService inventoryManagementService;
+	PaymentManagementService paymentManagementService;
+	ServiceManagementService serviceManagementService;
+	int index = m_dataStore.getUsers().find(userID);
+	if (index != -1)
+	{
+		User* user = m_dataStore.getUsers().getValueAt(index);
+		if (user != nullptr)
+		{
+			if (user->getUserType() == util::UserType::CUSTOMER)
+			{
+				serviceManagementService.cancelCustomerServiceBookings(userID);	
+			}
+			if (user->getUserType() == util::UserType::TECHNICIAN)
+			{
+				serviceManagementService.cancelTechnicianJobs(userID);
+			}
+			user->setState(util::State::INACTIVE);
+			inventoryManagementService.detach(user);
+			paymentManagementService.detach(user);
+			serviceManagementService.detach(user);
+		}
+	}
+}
 
 util::Map<std::string, User*> UserManagementService::getUsers(util::UserType type)
 {
@@ -8,24 +329,10 @@ util::Map<std::string, User*> UserManagementService::getUsers(util::UserType typ
 	for (int iterator = 0; iterator < currentUsers.getSize(); iterator++)
 	{
 		User* currentUser = currentUsers.getValueAt(iterator);
-		if (currentUser->getUserType() == type)
+		if (currentUser && currentUser->getState() == util::State::ACTIVE && currentUser->getUserType() == type)
 		{
 			filteredUsersMap.insert(currentUser->getId(), currentUser);
 		}
 	}
 	return filteredUsersMap;
-}
-
-User* UserManagementService::getUser(const std::string& userID)
-{
-	util::Map<std::string, User*>& currentUsers = m_dataStore.getUsers();
-	for (int iterator = 0; iterator < currentUsers.getSize(); iterator++)
-	{
-		User* currentUser = currentUsers.getValueAt(iterator);
-		if (currentUser->getId() == userID)
-		{
-			return currentUser;
-		}
-	}
-	return nullptr;
-}
+}

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

@@ -1,3 +1,11 @@
+/*
+File: UserManagementService.h
+Description: Header file declaring the UserManagementService class, which manages
+             user creation, updates, retrieval, removal, notifications, and ensures
+             the existence of an admin account.
+Author: Trenser
+Date:19-May-2026
+*/
 #pragma once
 #include <string>
 #include "Map.h"
@@ -13,12 +21,15 @@ private:
     DataStore& m_dataStore;
 public:
     UserManagementService() : m_dataStore(DataStore::getInstance()) {}
-    void createUser(const std::string& username, const std::string& password, const std::string& email, const std::string& phone, util::UserType type);
+    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 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);
+    void ensureAdminExists();
+    void loadUsers();
+    void saveUsers();
 };

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

@@ -0,0 +1,43 @@
+/*
+File: Config.h
+Description: Header file declaring configuration constants for the Vehicle Service System.
+			 Includes default admin account details such as username, name, password,
+			 email, and phone number.
+Author: Trenser
+Date: 21-May-2026
+*/
+
+#pragma once
+
+namespace config
+{
+	namespace admin
+	{
+		constexpr const char* DEFAULT_ADMIN_USERNAME = "admin";
+		constexpr const char* DEFAULT_ADMIN_NAME = "admin";
+		constexpr const char* DEFAULT_ADMIN_PASSWORD = "admin";
+		constexpr const char* DEFAULT_ADMIN_EMAIL = "admin@vss";
+		constexpr const char* DEFAULT_ADMIN_PHONE = "0000000000";
+	}
+
+	namespace threshold
+	{
+		constexpr int INVENTORY_LOW_STOCK_THRESHOLD = 5;
+		constexpr int PAYMENT_REMINDER_THRESHOLD_HOURS = 168;
+	}
+
+	namespace file
+	{
+		constexpr const char* INVENTORYITEM_FILE = "files/InventoryItem.csv";
+		constexpr const char* USER_FILE = "files/User.csv";
+		constexpr const char* NOTIFICATION_FILE = "files/Notification.csv";
+		constexpr const char* SERVICE_FILE = "files/Service.csv";
+		constexpr const char* COMBOPACKAGE_FILE = "files/ComboPackage.csv";
+		constexpr const char* SERVICEBOOKING_FILE = "files/ServiceBooking.csv";
+		constexpr const char* JOBCARD_FILE = "files/JobCard.csv";
+		constexpr const char* INVOICE_FILE = "files/Invoice.csv";
+		constexpr const char* SERVICEMANAGEMENTOBSERVERS = "files/ServiceManagementObservers.csv";
+		constexpr const char* PAYMENTMANAGEMENTOBSERVERS = "files/PaymentManagementObservers.csv";
+		constexpr const char* INVENTORYMANAGEMENTOBSERVERS = "files/InventoryManagementObservers.csv";
+	}
+}

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>
 
@@ -13,20 +22,24 @@ namespace util
 	enum class PaymentMode
 	{
 		ONLINE,
-		OFFLINE
+		OFFLINE,
+        NOTSET
 	};
 
 	enum class PaymentStatus
 	{
 		PENDING,
-		COMPLETED
+		COMPLETED,
+        PAID
 	};
 
 	enum class ServiceJobStatus
 	{
         PENDING,
 		STARTED,
-		COMPLETED
+		COMPLETED,
+        IN_PROGRESS,
+        CANCELLED
 	};
 
     enum class State
@@ -35,6 +48,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)
@@ -49,6 +70,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")
@@ -66,6 +97,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)
@@ -74,10 +113,22 @@ namespace util
             return "ONLINE";
         case PaymentMode::OFFLINE:
             return "OFFLINE";
+        case PaymentMode::NOTSET:
+            return "NOTSET";
         }
         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")
@@ -88,9 +139,21 @@ namespace util
         {
             return PaymentMode::OFFLINE;
         }
+        if (value == "NOTSET")
+        {
+            return PaymentMode::NOTSET;
+        }
         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)
@@ -99,10 +162,22 @@ namespace util
             return "PENDING";
         case PaymentStatus::COMPLETED:
             return "COMPLETED";
+        case PaymentStatus::PAID:
+            return "PAID";
         }
         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")
@@ -118,20 +193,42 @@ 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::PENDING:
-            return "STARTED";
+        case ServiceJobStatus::CANCELLED:
+            return "CANCELLED";
+        case ServiceJobStatus::IN_PROGRESS:
+            return "IN_PROGRESS";
         }
         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")
@@ -142,31 +239,61 @@ namespace util
         {
             return ServiceJobStatus::COMPLETED;
         }
+        if (value == "PENDING")
+        {
+            return ServiceJobStatus::PENDING;
+        }
+        if (value == "CANCELLED")
+        {
+            return ServiceJobStatus::CANCELLED;
+        }
+        if (value == "IN_PROGRESS")
+        {
+            return ServiceJobStatus::IN_PROGRESS;
+        }
         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)
         {
         case State::ACTIVE:
-            return "STARTED";
+            return "ACTIVE";
         case State::INACTIVE:
-            return "COMPLETED";
+            return "INACTIVE";
         }
         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")
         {
             return State::ACTIVE;
         }
-        if (value == "COMPLETED")
+        if (value == "INACTIVE")
         {
             return State::INACTIVE;
         }
         throw std::invalid_argument("Invalid State string");
     }
-}
+}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/FileHelper.h

@@ -0,0 +1,109 @@
+/*
+File: FileHelper.h
+Description: Provides utility functions for loading and saving records
+             from and to CSV-like text files. Ensures files are created
+             if missing and supports simple record persistence.
+Author: Trenser
+Date: 22-May-2026
+*/
+
+#pragma once
+#include <fstream>
+#include <string>
+#include <stdexcept>
+#include <direct.h>
+#include "Vector.h"
+
+namespace util
+{
+    /*
+    Function: ensureDirectoryExists
+    Description: Creates all missing directories present in the given file path.
+                Iteratively parses the path and creates each directory level
+                using _mkdir() before file operations are performed.
+    Parameters:
+        - filePath: const std::string&, relative or absolute file path
+    Returns:
+        - void
+    Throws:
+        - None (_mkdir failures are intentionally ignored if directory already exists)
+    */
+    inline void ensureDirectoryExists(const std::string& filePath)
+    {
+        size_t position = 0;
+
+        while ((position = filePath.find('/', position)) != std::string::npos)
+        {
+            std::string directory = filePath.substr(0, position);
+
+            if (!directory.empty())
+            {
+                (void)_mkdir(directory.c_str());
+            }
+            position++;
+        }
+    }
+
+    /*
+    Function: loadRecords
+    Description: Loads records from a given file path into a vector of strings.
+                 Skips the header line if present. Creates the file if it does not exist.
+    Parameters:
+        - filePath: const std::string&, path to the file
+    Returns:
+        - util::Vector<std::string>: Vector containing all records (excluding header)
+    Throws:
+        - None (creates file if missing)
+    */
+    inline util::Vector<std::string> loadRecords(const std::string& filePath)
+    {
+        util::Vector<std::string> records;
+        std::ifstream file(filePath);
+        if (!file.is_open())
+        {
+            ensureDirectoryExists(filePath);
+            std::ofstream newFile(filePath);
+            newFile.close();
+            file.open(filePath);
+        }
+        std::string line;
+        bool isHeader = true;
+        while (std::getline(file, line))
+        {
+            if (isHeader)
+            {
+                isHeader = false;
+                continue;
+            }
+            records.push_back(line);
+        }
+        return records;
+    }
+
+    /*
+    Function: saveRecords
+    Description: Saves records to a given file path. Overwrites existing content
+                 and writes a header line followed by all records.
+    Parameters:
+        - filePath: const std::string&, path to the file
+        - records: const util::Vector<std::string>&, vector of records to save
+    Returns:
+        - void
+    Throws:
+        - std::runtime_error if the file cannot be opened for writing
+    */
+    inline void saveRecords(const std::string& filePath, const util::Vector<std::string>& records)
+    {
+        std::ofstream file(filePath, std::ios::trunc);
+        if (!file.is_open())
+        {
+            throw std::runtime_error("Failed to open file " + filePath);
+        }
+        file << "Values" << '\n';
+        int numberOfRecords = records.getSize();
+        for (int index = 0; index < numberOfRecords; index++)
+        {
+            file << records[index] << '\n';
+        }
+    }
+}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/FileManager.h

@@ -0,0 +1,119 @@
+/*
+File: FileManager.h
+Description: Declares and implements a generic FileManager template class for
+			 loading and saving objects to and from files. Uses serialization
+			 and deserialization methods defined in the object type T.
+			 Provides persistence support for system entities such as Users,
+			 Services, InventoryItems, etc.
+Author: Trenser
+Date: 22-May-2026
+*/
+
+#pragma once
+#include <stdexcept>
+#include <string>
+#include <fstream>
+#include "Vector.h"
+#include "Map.h"
+#include "FileHelper.h"
+
+namespace util
+{
+	template <typename T> using objects = util::Map<std::string, T*>;
+
+	template <typename T>
+	class FileManager
+	{
+	private:
+		std::string m_filePath;
+	public:
+		FileManager() : m_filePath("") {}
+		FileManager(const std::string& filePath) : m_filePath(filePath) {}
+		objects<T> load();
+		void save(const objects<T>&);
+	};
+
+	/*
+	Function: load
+	Description: Loads records from the file into a map of objects.
+				 Skips the header line, deserializes each record into an object of type T,
+				 and stores them in a map keyed by object ID.
+	Parameters:
+		- None
+	Returns:
+		- util::Map<std::string, T*> containing deserialized objects
+	Throws:
+		- std::runtime_error if deserialization fails for any record
+	*/
+	template <typename T>
+	objects<T> FileManager<T>::load()
+	{
+		objects<T> records;
+		std::ifstream file(m_filePath);
+		if (!file.is_open())
+		{
+			ensureDirectoryExists(m_filePath);
+			std::ofstream newFile(m_filePath);
+			newFile.close();
+			file.open(m_filePath);
+		}
+		util::Vector<std::string> lines;
+		std::string line;
+		while (std::getline(file, line))
+		{
+			lines.push_back(line);
+		}
+		int numberOfLines = lines.getSize();
+		bool isHeader = true;
+		for (int lineIndex = 0; lineIndex < numberOfLines; lineIndex++)
+		{
+			const auto& record = lines[lineIndex];
+			if (isHeader)
+			{
+				isHeader = false;
+				continue;
+			}
+			auto object = T::deserialize(record);
+			if (!object)
+			{
+				throw std::runtime_error("Failed to deserialize record");
+			}
+			records[object->getId()] = object;
+		}
+		return records;
+	}
+
+	/*
+	Function: save
+	Description: Saves records to the file. Serializes each object of type T into a string,
+				 writes a header line, and then writes all serialized records to the file.
+	Parameters:
+		- records: const util::Map<std::string, T*>&, map of objects to save
+	Returns:
+		- void
+	Throws:
+		- std::runtime_error if the file cannot be opened for writing
+	*/
+	template <typename T>
+	void FileManager<T>::save(const objects<T>& records)
+	{
+		util::Vector<std::string> lines;
+		lines.push_back(T::getHeaders());
+		int numberOfRecords = records.getSize();
+		for (int recordIndex = 0; recordIndex < numberOfRecords; recordIndex++)
+		{
+			const auto& record = records.getValueAt(recordIndex);
+			lines.push_back(record->serialize());
+		}
+		std::ofstream file(m_filePath, std::ios::trunc);
+		if (!file.is_open())
+		{
+			throw std::runtime_error("Failed to open file " + m_filePath);
+		}
+		int numberOfLines = lines.getSize();
+		for (int lineIndex = 0; lineIndex < numberOfLines; lineIndex++)
+		{
+			file << lines[lineIndex] << '\n';
+		}
+	}
+}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/InputHelper.h

@@ -34,7 +34,7 @@ namespace util
 
     /*
      * Function: read
-     * Description: Reads a line of text input from console into a string.
+     * Description: Reads a line of text input from console into a string and cleans it up.
      * Parameters:
      *     value - reference to a string where the input will be stored
      * Returns:
@@ -43,6 +43,15 @@ namespace util
     inline void read(std::string& value)
     {
         std::getline(std::cin >> std::ws, value);
+        std::string cleanedValue;
+        for (int index = 0; index < value.length(); index++)
+        {
+            if (value[index] != ',')
+            {
+                cleanedValue += value[index];
+            }
+        }
+        value = cleanedValue;
     }
 
     /*
@@ -53,6 +62,7 @@ namespace util
      */
     inline void pressEnter()
     {
+        std::cout << std::endl;
         system("pause");
     }
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/OutputHelper.h

@@ -21,4 +21,28 @@ namespace util
     {
         std::cout << "\x1B[2J\x1B[H" << std::flush;
     }
+
+    /*
+    Function: truncateString
+    Description:
+        Truncates a string if its length exceeds the given maximum length.
+        The truncated string ends with "..." to indicate omitted characters.
+    Parameters:
+        - text: const std::string&, input string to truncate
+        - maxLength: size_t, maximum allowed length of the returned string
+    Returns:
+        - std::string: Original string if within limit, otherwise truncated string with "..."
+    */
+    inline std::string truncateString(const std::string& text, size_t maxLength)
+    {
+        if (text.length() <= maxLength)
+        {
+            return text;
+        }
+        if (maxLength <= 3)
+        {
+            return std::string(maxLength, '.');
+        }
+        return text.substr(0, maxLength - 3) + "...";
+    }
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/StringHelper.h

@@ -0,0 +1,36 @@
+/*
+File: StringHelper.h
+Description: Provides utility functions for extracting numeric values from strings.
+             Useful for parsing IDs, codes, or mixed alphanumeric inputs where
+             digits need to be isolated and converted into integers.
+Author: Trenser
+Date: 22-May-2026
+*/
+
+#include <cctype>
+#include <string>
+
+namespace util
+{
+    /*
+    Function: extractNumber
+    Description: Extracts all digits from the given string and converts them into an integer.
+                 Ignores non-digit characters. For example, "abc123xyz" returns 123.
+    Parameters:
+        - input: const std::string&, the input string containing digits and/or other characters
+    Returns:
+        - int: The integer value formed by concatenating all digits in the string
+    */
+    inline int extractNumber(const std::string& input)
+    {
+        int result = 0;
+        for (char character : input)
+        {
+            if (std::isdigit(static_cast<unsigned char>(character)))
+            {
+                result = result * 10 + (character - '0');
+            }
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,102 @@
+/*
+File: Utility.h
+Description: Header file declaring utility functions used across the system
+Author: Trenser
+Date:19-May-2026
+*/
+
+#pragma once
+#include "ComboPackage.h"
+#include "DataStore.h"
+#include "FileHelper.h"
+#include "InventoryItem.h"
+#include "NotificationManagementService.h"
+#include "Service.h"
+
+namespace util
+{
+    /*
+    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;
+    }
+
+    /*
+    Function: calculateComboServiceEstimatedCost
+    Description: Calculates the estimated total cost of a combo package by summing
+                  the labor and parts costs of all services included in the package.
+    Parameter: const ComboPackage* comboPackage - pointer to the combo package object
+    Return type: double - estimated total cost of the combo package
+    */
+    inline double calculateComboServiceEstimatedCost(const ComboPackage* comboPackage)
+    {
+        double cost = 0;
+        auto& services = comboPackage->getServices();
+        int servicesSize = services.getSize();
+        for (int index = 0; index < servicesSize; index++)
+        {
+            const Service* service = services.getValueAt(index);
+            cost += calculatePartsCost(service) + service->getLaborCost();
+        }
+        return cost;
+    }
+
+    /*
+    Function: loadObservers
+    Description: Loads observer IDs from a file and attaches the corresponding users
+                 to the notification management service. Validates that each observer ID
+                 exists in the datastore before attaching.
+    Parameters:
+        - filePath: const std::string&, path to the file containing observer IDs
+        - service: NotificationManagementService*, pointer to the notification service
+        - dataStore: DataStore&, reference to the datastore containing users
+    Returns:
+        - void
+    Throws:
+        - std::runtime_error if an observer ID is invalid (not found in datastore)
+    */
+    inline void loadObservers(const std::string& filePath, NotificationManagementService* service, DataStore& dataStore)
+    {
+        auto observerIDs = util::loadRecords(filePath);
+        auto& users = dataStore.getUsers();
+        for (int index = 0; index < observerIDs.getSize(); index++)
+        {
+            const std::string& observerID = observerIDs[index];
+            int userIndex = users.find(observerID);
+            if (userIndex == -1)
+            {
+                throw std::runtime_error("Invalid Observer ID");
+            }
+            service->attach(users.getValueAt(userIndex));
+        }
+    }
+
+    /*
+    Function: saveObservers
+    Description: Saves the current observer IDs from the notification management service
+                 to a file for persistence.
+    Parameters:
+        - filePath: const std::string&, path to the file where observer IDs will be saved
+        - service: NotificationManagementService*, pointer to the notification service
+    Returns:
+        - void
+    */
+    inline void saveObservers(const std::string& filePath, NotificationManagementService* service)
+    {
+        auto observerIDs = service->getObserverIDs();
+        util::saveRecords(filePath, observerIDs);
+    }
+}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/Validator.cpp

@@ -106,4 +106,70 @@ bool util::isPasswordValid(const std::string& password)
     }
 
     return hasUpper && hasLower && hasDigit && hasSpecial;
+}
+
+/*
+ * Function: isUsernameDuplicate
+ * Description: Checks if the given username already exists among active users.
+ * Parameters:
+ *     username - string containing the username to validate
+ *     usersMap - map of user objects keyed by identifier
+ * Returns:
+ *     bool - true if the username is already in use by an active user, false otherwise
+ * Notes:
+ *     - Only considers users with state util::State::ACTIVE
+ */
+bool util::isUsernameDuplicate(const std::string& username, const util::Map<std::string, User*>& usersMap)
+{
+    int index = usersMap.findIf(
+        [&](const std::string&, User* user)
+        {
+            return (user->getUserName() == username && user->getState() == util::State::ACTIVE);
+        }
+    );
+    return index != -1;
+}
+
+/*
+ * Function: isPhoneDuplicate
+ * Description: Checks if the given phone number already exists among active users.
+ * Parameters:
+ *     phone - string containing the phone number to validate
+ *     usersMap - map of user objects keyed by identifier
+ * Returns:
+ *     bool - true if the phone number is already in use by an active user, false otherwise
+ * Notes:
+ *     - Only considers users with state util::State::ACTIVE
+ */
+bool util::isPhoneDuplicate(const std::string& phone, const util::Map<std::string, User*>& usersMap)
+{
+    int index = usersMap.findIf(
+        [&](const std::string&, User* user)
+        {
+            return (user->getPhone() == phone && user->getState() == util::State::ACTIVE);
+        }
+    );
+    return index != -1;
+}
+
+/*
+ * Function: isEmailDuplicate
+ * Description: Checks if the given email address already exists among active users.
+ * Parameters:
+ *     email - string containing the email address to validate
+ *     usersMap - map of user objects keyed by identifier
+ * Returns:
+ *     bool - true if the email address is already in use by an active user, false otherwise
+ * Notes:
+ *     - Only considers users with state util::State::ACTIVE
+ */
+bool util::isEmailDuplicate(const std::string& email, const util::Map<std::string, User*>& usersMap)
+{
+    int index = usersMap.findIf(
+        [&](const std::string&, User* user)
+        {
+            return (user->getEmail() == email && user->getState() == util::State::ACTIVE);
+        }
+    );
+    return index != -1;
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/Validator.h

@@ -9,10 +9,15 @@
 #include<string>
 #include<algorithm>
 #include<cctype>
+#include "Map.h"
+#include "User.h"
 
 namespace util
 {
 	bool isPhoneNumberValid(const std::string&);
 	bool isEmailValid(const std::string&);
 	bool isPasswordValid(const std::string&);
+	bool isUsernameDuplicate(const std::string&, const util::Map<std::string, User*>&);
+	bool isPhoneDuplicate(const std::string&, const util::Map<std::string, User*>&);
+	bool isEmailDuplicate(const std::string&, const util::Map<std::string, User*>&);
 }

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

@@ -1,3 +1,12 @@
+/*
+File: AdminMenu.h
+Description: Header file declaring the AdminMenu class, which provides
+             administrative operations such as inventory management,
+             user management, service configuration, and notifications.
+Author: Trenser
+Date:19-May-2026
+*/
+
 #pragma once
 #include "Controller.h"
 
@@ -15,10 +24,14 @@ public:
     void removeInventoryItem();
     void checkStockAvailability();
     void assignJob();
+    void displayServices();
     void createService();
     void removeService();
+    void displayUsers();
+    void confirmPayment();
     void addTechnician();
     void removeUser();
+    void displayComboPackages();
     void createComboPackages();
     void removeComboPackage();
     void viewNotifications();

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

@@ -1,58 +1,252 @@
+/*
+File: CustomerMenu.cpp
+Description: Implementation file containing the method definitions of the
+             CustomerMenu class, including menu handling, service selection,
+             combo package booking, profile updates, and password management.
+Author: Trenser
+Date:19-May-2026
+*/
+
 #include <iomanip>
+#include "ComboPackage.h"
 #include "CustomerMenu.h"
+#include "MenuHelper.h"
+#include "Enums.h"
 #include "InputHelper.h"
 #include "OutputHelper.h"
-#include "User.h"
+#include "InventoryItem.h"
+#include "Invoice.h"
+#include "Map.h"
+#include "Service.h"
 #include "ServiceBooking.h"
-#include "Enums.h"
+#include "Timestamp.h"
+#include "User.h"
+#include "Validator.h"
+#include "Vector.h"
+
+/*
+Function: showMenu
+Description: Displays the customer menu and handles user input until logout is selected.
+Parameter: None
+Return type: void
+*/
 
 void CustomerMenu::showMenu()
 {
-	bool isMenuActive = true;
-	while (isMenuActive)
-	{
-		try
-		{
-			int choice;
-			util::clear();
-			std::cout << "" << std::endl;
-			util::read(choice);
-			if (!handleOperation(choice))
-			{
-				isMenuActive = false;
-			}
-		}
-		catch (const std::exception& e)
-		{
-			std::cout << "Exception: " << e.what() << std::endl;
-			util::pressEnter();
-		}
-	}
+    while (true)
+    {
+        try
+        {
+            int choice;
+            util::clear();
+            std::cout << "Customer Menu"
+                << "\n1. Select a service"
+                << "\n2. Select a combo package"
+                << "\n3. Update Profile"
+                << "\n4. Change Password"
+                << "\n5. View Service History"
+                << "\n6. Complete Payments"
+                << "\n7. View Invoices"
+                << "\n8. View Notifications"
+                << "\n9. Configure Notifications"
+                << "\n10. Logout"
+                << "\nEnter a choice: ";
+            util::read(choice);
+            if (!handleOperation(choice))
+            {
+                break;
+            }
+        }
+        catch (const std::exception& e)
+        {
+            std::cout << "Exception: " << e.what() << std::endl;
+            util::pressEnter();
+        }
+    }
 }
 
+/*
+Function: handleOperation
+Description: Executes the corresponding customer operation based on the selected menu choice.
+Parameter: int choice - selected menu option
+Return type: bool - true if menu continues, false if logout
+*/
 bool CustomerMenu::handleOperation(int choice)
 {
-	return false;
+    switch (choice)
+    {
+    case 1:
+        selectService();
+        break;
+    case 2:
+        selectComboPackage();
+        break;
+    case 3:
+        updateDetails();
+        break;
+    case 4:
+        changePassword();
+        break;
+    case 5:
+        viewServiceHistory();
+        break;
+    case 6:
+        completePayments();
+        break;
+    case 7:
+        viewInvoices();
+        break;
+    case 8:
+        viewNotifications();
+        break;
+    case 9:
+        configureNotifications();
+        break;
+    case 10:
+        logout();
+        return false;
+    default:
+        std::cout << "Enter a valid choice!" << std::endl;
+        util::pressEnter();
+    }
+    return true;
 }
 
+/*
+Function: logout
+Description: Logs out the currently authenticated customer user.
+Parameter: None
+Return type: void
+*/
 void CustomerMenu::logout()
 {
+	m_controller.logout();
 }
 
+/*
+Function: changePassword
+Description: Allows the customer to change their password after validation.
+Parameter: None
+Return type: void
+*/
 void CustomerMenu::changePassword()
 {
+    changePasswordHelper(m_controller);
 }
 
+/*
+Function: updateDetails
+Description: Allows the customer to update their email and phone number after validation.
+Parameter: None
+Return type: void
+*/
 void CustomerMenu::updateDetails()
 {
+	std::string email, phone;
+	util::clear();
+    std::cout << "Update Details\n";
+	std::cout << "Enter new email: ";
+	util::read(email);
+	if (!util::isEmailValid(email))
+	{
+		std::cout << "Error: Email is invalid!\n";
+		util::pressEnter();
+		return;
+	}
+	std::cout << "Enter new phone: ";
+	util::read(phone);
+	if (!util::isPhoneNumberValid(phone))
+	{
+		std::cout << "Error: Phone number is invalid!\n";
+		util::pressEnter();
+		return;
+	}
+	m_controller.updateUserDetails(email, phone);
+	std::cout << "Profile details updated successfully\n";
+	util::pressEnter();
 }
 
+/*
+Function: selectService
+Description: Allows the customer to select a service, provide vehicle details,
+             and book the service through the controller.
+Parameter: None
+Return type: void
+*/
 void CustomerMenu::selectService()
 {
+    std::string vehicleNumber, vehicleBrand, vehicleModel;
+    util::clear();
+    std::cout << "Select a Service\n";
+	auto services = m_controller.getServices();
+    if (services.isEmpty())
+    {
+        std::cout << "No services available!";
+        util::pressEnter();
+        return;
+    }
+    util::Vector<std::string> selectedServices;
+    const Service* selectedService = selectServiceFromServices(services);
+    if (selectedService == nullptr)
+    {
+        std::cout << "Failed to book service!";
+        util::pressEnter();
+        return;
+    }
+    selectedServices.push_back(selectedService->getId());
+    util::clear();
+    std::cout << "Enter Vehicle Details\n";
+    std::cout << "Enter vehicle number: ";
+    util::read(vehicleNumber);
+    std::cout << "Enter vehicle brand: ";
+    util::read(vehicleBrand);
+    std::cout << "Enter vehicle model: ";
+    util::read(vehicleModel);
+    m_controller.purchaseService(selectedServices, vehicleNumber, vehicleBrand, vehicleModel);
+    std::cout << "Service has been booked successfully";
+    util::pressEnter();
 }
 
+/*
+Function: selectComboPackage
+Description: Allows the customer to select a combo package, provide vehicle details,
+             and book the package through the controller.
+Parameter: None
+Return type: void
+*/
 void CustomerMenu::selectComboPackage()
 {
+    std::string vehicleNumber, vehicleBrand, vehicleModel;
+    util::clear();
+    std::cout << "Select a Combo Package\n";
+    auto comboPackages = m_controller.getComboPackages();
+    util::Map<std::string, const ComboPackage*> activeComboPackages = filterComboPackages(comboPackages);
+    if (activeComboPackages.isEmpty())
+    {
+        std::cout << "No combo packages available!\n\n";
+        util::pressEnter();
+        return;
+    }
+    const ComboPackage* selectedComboPackage = selectComboPackageFromPackages(activeComboPackages);
+    if (selectedComboPackage == nullptr)
+    {
+        std::cout << "Failed to book combo package!\n\n";
+        util::pressEnter();
+        return;
+    }
+    std::cout << "Combo Package selected\n";
+    util::pressEnter();
+    util::clear();
+    std::cout << "Enter the vehicle details\n";
+    std::cout << "Enter vehicle number: ";
+    util::read(vehicleNumber);
+    std::cout << "Enter vehicle brand: ";
+    util::read(vehicleBrand);
+    std::cout << "Enter vehicle model: ";
+    util::read(vehicleModel);
+    m_controller.purchaseComboPackage(selectedComboPackage->getId(), vehicleNumber, vehicleBrand, vehicleModel);
+    std::cout << "Combo Package has been booked successfully\n\n";
+    util::pressEnter();
 }
 
 /*
@@ -71,16 +265,17 @@ void CustomerMenu::viewServiceHistory()
 	const User* currentUser = m_controller.getAuthenticatedUser();
 	std::string currentUserID = currentUser->getId();
 	util::Map<std::string, const ServiceBooking*> serviceBookingsByCurrentUser = m_controller.getServiceBookingsByUser(currentUserID);
+    std::cout << "View Service History" << std::endl;
     if (serviceBookingsByCurrentUser.getSize() != 0)
     {
         std::cout << std::left
-            << std::setw(12) << "Booking ID"
+            << std::setw(15) << "Booking ID"
             << std::setw(20) << "Technician"
-            << std::setw(15) << "Vehicle Brand"
-            << std::setw(15) << "Vehicle Number"
-            << std::setw(15) << "Vehicle Model"
-            << std::setw(10) << "Discount %"
-            << std::setw(12) << "Status"
+            << std::setw(20) << "Vehicle Brand"
+            << std::setw(20) << "Vehicle Number"
+            << std::setw(20) << "Vehicle Model"
+            << std::setw(20) << "Discount %"
+            << std::setw(20) << "Status"
             << std::endl;
         for (int iterator = 0; iterator < serviceBookingsByCurrentUser.getSize(); iterator++)
         {
@@ -89,13 +284,13 @@ void CustomerMenu::viewServiceHistory()
                 ? "Not Assigned"
                 : currentBooking->getAssignedTechnician()->getName();
             std::cout << std::left
-                << std::setw(12) << currentBooking->getId()
+                << std::setw(15) << currentBooking->getId()
                 << std::setw(20) << technicianName
-                << std::setw(15) << currentBooking->getVehicleBrand()
-                << std::setw(15) << currentBooking->getVehicleNumber()
-                << std::setw(15) << currentBooking->getVehicleModel()
-                << std::setw(10) << currentBooking->getDiscountPercentage()
-                << std::setw(12) << util::getServiceJobStatusString(currentBooking->getStatus())
+                << std::setw(20) << currentBooking->getVehicleBrand()
+                << std::setw(20) << currentBooking->getVehicleNumber()
+                << std::setw(20) << currentBooking->getVehicleModel()
+                << std::setw(20) << currentBooking->getDiscountPercentage()
+                << std::setw(20) << util::getServiceJobStatusString(currentBooking->getStatus())
                 << std::endl;
             hasServiceHistory = true;
         }
@@ -104,20 +299,103 @@ void CustomerMenu::viewServiceHistory()
     {
         std::cout << "No history available." << std::endl;
     }
+    util::pressEnter();
 }
 
+/*
+Function: completePayments
+Description: Allows the customer to complete pending payments for invoices.
+             Validates invoice selection and payment mode before completing payment.
+Parameters:
+    - None
+Returns:
+    - void
+*/
 void CustomerMenu::completePayments()
 {
+	util::clear();
+    std::cout << "Complete Payments\n";
+	util::Map<std::string, const Invoice*> currentInvoices = m_controller.getInvoicesByUser();
+    if (currentInvoices.isEmpty())
+    {
+        std::cout << "No pending invoices available for payment.\n";
+        util::pressEnter();
+        return;
+    }
+    bool hasPending = false;
+    for (int index = 0; index < currentInvoices.getSize(); ++index)
+    {
+        const Invoice* invoice = currentInvoices.getValueAt(index);
+        if (invoice && invoice->getStatus() == util::PaymentStatus::PENDING)
+        {
+            hasPending = true;
+            break;
+        }
+    }
+    if (!hasPending)
+    {
+        std::cout << "No pending invoices available for payment.\n";
+        util::pressEnter();
+        return;
+    }
+	std::string selectedID = selectInvoiceFromUserForPayment(currentInvoices, util::PaymentStatus::PENDING);
+    if (selectedID == "")
+    {
+        std::cout << "Payment failed.\n";
+        util::pressEnter();
+        return;
+    }
+    util::PaymentMode paymentMode = selectPaymentMode();
+    m_controller.completePayment(selectedID, paymentMode);
+    std::cout << "Payment completed successfully.\n";
+    util::pressEnter();
 }
 
+/*
+Function: viewInvoices
+Description: Displays invoices associated with the customer by calling displayInvoices.
+Parameters:
+    - None
+Returns:
+    - void
+*/
 void CustomerMenu::viewInvoices()
 {
+	util::clear();
+    std::cout << "View Invoices\n";
+	util::Map<std::string, const Invoice*> currentUserInvoices = m_controller.getInvoicesByUser();
+	displayInvoices(currentUserInvoices);
+    util::pressEnter();
 }
 
+/*
+Function: viewNotifications
+Description: Displays notifications for the customer and allows deletion of notifications.
+Parameters:
+    - None
+Returns:
+    - void
+*/
 void CustomerMenu::viewNotifications()
 {
+	viewAndDeleteNotification(m_controller);
 }
 
+
+/*
+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,13 @@
+/*
+File: CustomerMenu.h
+Description: Header file declaring the CustomerMenu class, which provides
+             customer operations such as selecting services, booking combo
+             packages, updating profile details, managing payments, viewing
+             invoices, and configuring notifications.
+Author: Trenser
+Date:19-May-2026
+*/
+
 #pragma once
 #include "Controller.h"
 

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

@@ -1,122 +1,184 @@
-#include <iomanip>
-#include "TechnicianMenu.h"
-#include "InputHelper.h"
-#include "OutputHelper.h"
-#include "JobCard.h"
-#include "Enums.h"
-#include "Service.h"
+/*
+File: TechnicianMenu.cpp
+Description: Implementation file containing the method definitions of the
+             TechnicianMenu class, including menu handling, job completion,
+             notification viewing, password management, and logout logic.
+Author: Trenser
+Date:19-May-2026
+*/
 
+#include "Enums.h"
+#include "InputHelper.h"
+#include "JobCard.h"
+#include "MenuHelper.h"
+#include "OutputHelper.h"
+#include "Service.h"
+#include "TechnicianMenu.h"
+#include "Validator.h"
+
+/*
+Function: showMenu
+Description: Displays the technician menu in a loop until the user chooses to logout.
+			 Handles exceptions and ensures smooth user interaction.
+Parameters:
+	- None
+Returns:
+	- void
+*/
 void TechnicianMenu::showMenu()
 {
-	bool isMenuActive = true;
-	while (isMenuActive)
-	{
-		try
-		{
-			int choice;
-			util::clear();
-			std::cout << "" << std::endl;
-			util::read(choice);
-			if (!handleOperation(choice))
-			{
-				isMenuActive = false;
-			}
-		}
-		catch (const std::exception& e)
-		{
-			std::cout << "Exception: " << e.what() << std::endl;
-			util::pressEnter();
-		}
-	}
-}
-
-bool TechnicianMenu::handleOperation(int choice)
-{
-	return false;
-}
-
-/*
-Function: selectJobCardToComplete (static helper)
-Description: Lists all incomplete job cards assigned to the technician and allows selection by index.
-Parameters:
-    - assignedJobCards: util::Map<std::string, const JobCard*>&, job cards assigned to the technician
-    - incompleteJobCards: util::Map<int, const JobCard*>&, map of incomplete job cards indexed for selection
-Returns:
-    - std::string: ID of the selected job card, or empty string if none selected
-*/
-static std::string selectJobCardToComplete(util::Map<std::string, const JobCard*>& assignedJobCards, util::Map<int, const JobCard*>& incompleteJobCards)
-{
-    int currentIndex = 1;
-    int choice;
-    bool hasIncompleteJobCard = false;
-    std::cout << std::left
-        << std::setw(6) << "Index"
-        << std::setw(12) << "BookingID"
-        << std::setw(12) << "JobID"
-        << std::setw(20) << "ServiceName"
-        << std::setw(12) << "ServiceID"
-        << std::endl;
-    for (int iterator = 0; iterator < assignedJobCards.getSize(); iterator++)
+    while (true)
     {
-        const JobCard* currentJobCard = assignedJobCards.getValueAt(iterator);
-        if (currentJobCard && (currentJobCard->getStatus() == util::ServiceJobStatus::STARTED))
+        try
         {
-            std::cout << std::left << std::setw(6) << currentIndex
-                << std::setw(12) << currentJobCard->getBookingId()
-                << std::setw(12) << currentJobCard->getId()
-                << std::setw(20) << currentJobCard->getService()->getName()
-                << std::setw(12) << currentJobCard->getServiceId()
-                << std::endl;
-            hasIncompleteJobCard = true;
-            incompleteJobCards.insert(currentIndex++, currentJobCard);
+            int choice;
+            util::clear();
+            std::cout << "Technician Menu"
+                << "\n1. Display My Jobs"
+                << "\n2. Update Job Status"
+                << "\n3. View Notifications"
+                << "\n4. Change Password"
+                << "\n5. Logout"
+                << "\nEnter a choice: ";
+            util::read(choice);
+            if (!handleOperation(choice))
+            {
+                break;
+            }
+        }
+        catch (const std::exception& e)
+        {
+            std::cout << "Exception: " << e.what() << std::endl;
+            util::pressEnter();
         }
     }
-    if (!hasIncompleteJobCard)
-    {
-        std::cout << "No pending jobs are present.\n";
-        return "";
-    }
-    std::cout << "Select the Job Card to complete (Index): ";
-    util::read(choice);
-    int selectedJobCardIndex = incompleteJobCards.find(choice);
-    if (selectedJobCardIndex != -1)
-    {
-        const JobCard* selectedJobCard = incompleteJobCards.getValueAt(selectedJobCardIndex);
-        return selectedJobCard->getId();
-    }
-    else
-    {
-        std::cout << "Invalid choice.\n";
-        return "";
-    }
 }
 
 /*
-Function: completeJob
-Description: Allows the technician to mark a selected job card as completed.
+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:
+        displayJobs();
+        break;
+    case 2:
+        updateJobStatus();
+        break;
+    case 3:
+        viewNotifications();
+        break;
+    case 4:
+        changePassword();
+        break;
+    case 5:
+        logout();
+        return false;
+    default:
+        std::cout << "Enter a valid choice!" << std::endl;
+        util::pressEnter();
+    }
+    return true;
+}
+
+/*
+Function: displayJobs
+Description: Displays all Jobs assigned to a Technician
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void TechnicianMenu::displayJobs()
+{
+    util::clear();
+    std::cout << "My Jobs\n";
+    util::Map<std::string, const JobCard*> assignedJobCards = m_controller.getJobCardsByUser();
+    util::Map<std::string, const JobCard*> jobCards = filterStartedJobCards(assignedJobCards);
+    displayAllJobs(jobCards);
+    util::pressEnter();
+}
+
+/*
+Function: updateJobStatus
+Description: Allows the technician to update a selected job card.
              Validates selection and updates job status through the controller.
 Parameters:
     - None
 Returns:
     - void
 */
-void TechnicianMenu::completeJob()
+void TechnicianMenu::updateJobStatus()
 {
+    util::clear();
+    std::cout << "Update Job Status\n";
+    int choice;
+    std::string selectedJobID;
+    util::ServiceJobStatus selectedJobStatus = util::ServiceJobStatus::PENDING;
 	util::Map<std::string, const JobCard*> assignedJobCards = m_controller.getJobCardsByUser();
-	util::Map<int, const JobCard*> incompleteJobCards;
-	std::cout << "Jobs to be completed.\n";
-	std::string selectedJobID = selectJobCardToComplete(assignedJobCards, incompleteJobCards);
-	if (selectedJobID == "")
+    std::cout << "Select the type of job you want to update\n1.Started\n2.Inprogress\nChoice: ";
+    util::read(choice);
+    if (choice == 1)
+    {
+        selectedJobStatus = util::ServiceJobStatus::STARTED;
+    }
+    else if (choice == 2)
+    {
+        selectedJobStatus = util::ServiceJobStatus::IN_PROGRESS;
+    }
+    else
+    {
+        std::cout << "Invalid choice. Please try again.\n";
+        util::pressEnter();
+        return;
+    }
+    util::Map<std::string, const JobCard*> selectedTypeJobCard = filterJobCards(assignedJobCards, selectedJobStatus);
+	selectedJobID = selectJobCardToUpdate(selectedTypeJobCard, selectedJobStatus);
+    if (!selectedJobID.empty())
 	{
-		std::cout << "Failed to complete the job.\n";
-	}
-	else
-	{
-		m_controller.completeJob(selectedJobID);
-		std::cout << "Job marked as completed.\n";
+		m_controller.updateJobStatus(selectedJobID);
+		std::cout << "\nJob status updated.\n\n";
 	}
+    util::pressEnter();
 }
 
+/*
+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()
+{
+    changePasswordHelper(m_controller);
+}

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

@@ -1,3 +1,12 @@
+/*
+File: TechnicianMenu.h
+Description: Header file declaring the TechnicianMenu class, which provides
+             technician operations such as job completion, notification viewing,
+             password management, and logout functionality.
+Author: Trenser
+Date:19-May-2026
+*/
+
 #pragma once
 #include "Controller.h"
 
@@ -8,6 +17,9 @@ private:
     bool handleOperation(int choice);
 public:
     void showMenu();
-    void completeJob();
+    void displayJobs();
+    void updateJobStatus();
     void viewNotifications();
+    void logout();
+    void changePassword();
 };

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

@@ -1,31 +1,76 @@
-#include "UserInterface.h"
+/*
+File: UserInterface.cpp
+Description: Implementation file containing the method definitions of the
+			 UserInterface class, including system run loop, login handling,
+			 and customer registration logic.
+Author: Trenser
+Date:19-May-2026
+*/
+
+#include <iostream>
+#include <stdexcept>
+#include "Enums.h"
 #include "InputHelper.h"
 #include "OutputHelper.h"
+#include "User.h"
+#include "UserInterface.h"
+#include "Validator.h"
 
+/*
+Function: run
+Description: Runs the main system loop, displaying the initial menu for login,
+			 customer registration, or exit. Handles exceptions gracefully.
+Parameter: None
+Return type: void
+*/
 void UserInterface::run()
 {
-	bool isMenuActive = true;
-	while (isMenuActive)
+	try
 	{
-		try
+		m_controller.loadSystemData();
+		m_controller.runSystemChecks();
+		bool isMenuActive = true;
+		while (isMenuActive)
 		{
-			int choice;
-			util::clear();
-			std::cout << "Vehicle Service System\n1. Login\n2. Register Customer\n3. Exit\nEnter your Choice: ";
-			util::read(choice);
-			if (!handleOperation(choice))
+			try
 			{
-				isMenuActive = false;
+				int choice;
+				util::clear();
+				std::cout << "Vehicle Service System\n1. Login\n2. Register Customer\n3. Exit\nEnter your Choice: ";
+				util::read(choice);
+				if (!handleOperation(choice))
+				{
+					isMenuActive = false;
+				}
+			}
+			catch (const std::exception& e)
+			{
+				std::cout << "Exception: " << e.what() << std::endl;
+				util::pressEnter();
 			}
 		}
-		catch (const std::exception& e)
-		{
-			std::cout << "Exception: " << e.what() << std::endl;
-			util::pressEnter();
-		}
+		m_controller.saveSystemData();
+	}
+	catch (const std::invalid_argument& exception)
+	{
+		std::cout << "Exception: Invalid Argument: " << exception.what() << std::endl;
+	}
+	catch (const std::exception& exception)
+	{
+		std::cout << "Exception: " << exception.what() << std::endl;
+	}
+	catch (...)
+	{
+		std::cout << "Unknown error occurred." << std::endl;
 	}
 }
 
+/*
+Function: handleOperation
+Description: Executes the corresponding system operation based on the selected menu choice.
+Parameter: int choice - selected menu option
+Return type: bool - true if menu continues, false if exit
+*/
 bool UserInterface::handleOperation(int choice)
 {
 	switch (choice)
@@ -46,12 +91,98 @@ bool UserInterface::handleOperation(int choice)
 	return true;
 }
 
+/*
+Function: login
+Description: Handles user login by validating credentials. Based on the authenticated
+			 user type, navigates to the appropriate menu (Admin, Technician, Customer).
+Parameter: None
+Return type: void
+*/
 void UserInterface::login()
 {
-
+	std::string username, password;
+	util::clear();
+	std::cout << "Login\n";
+	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 && authenticatedUser->getState() != util::State::INACTIVE)
+		{
+			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 if (authenticatedUser && authenticatedUser->getState() == util::State::INACTIVE)
+		{
+			std::cout << "\nError: Your account has been disabled. Please contact your Administrator.";
+			util::pressEnter();
+		}
+	}
+	else
+	{
+		std::cout << "\nError: Invalid Username or Password";
+		util::pressEnter();
+	}
 }
 
+/*
+Function: registerCustomer
+Description: Registers a new customer by collecting and validating details such as
+			 username, name, email, password, and phone number. Delegates creation
+			 to the controller.
+Parameter: None
+Return type: void
+*/
 void UserInterface::registerCustomer()
 {
-
+	std::string username, name, email, phone, password;
+	util::clear();
+	std::cout << "Register Customer\n";
+	std::cout << "Enter username: ";
+	util::read(username);
+	std::cout << "Enter name: ";
+	util::read(name);
+	std::cout << "Enter email: ";
+	util::read(email);
+	if (!util::isEmailValid(email))
+	{
+		std::cout << "Error: Email is invalid!";
+		util::pressEnter();
+		return;
+	}
+	std::cout << "Enter password: ";
+	util::read(password);
+	if (!util::isPasswordValid(password))
+	{
+		std::cout << "Error: Password is invalid!";
+		util::pressEnter();
+		return;
+	}
+	std::cout << "Enter phone: ";
+	util::read(phone);
+	if (!util::isPhoneNumberValid(phone))
+	{
+		std::cout << "Error: Phone number is invalid!";
+		util::pressEnter();
+		return;
+	}
+	m_controller.createCustomer(username, name, password, email, phone);
+	std::cout << "Registration is successful";
+	util::pressEnter();
 }

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

@@ -1,3 +1,13 @@
+/*
+File: UserInterface.h
+Description: Header file declaring the UserInterface class, which provides
+             the main entry point for the Vehicle Service System. Handles
+             login, customer registration, and menu navigation for different
+             user roles (Admin, Technician, Customer).
+Author: Trenser
+Date:19-May-2026
+*/
+
 #pragma once
 #include "Controller.h"
 #include "AdminMenu.h"
@@ -17,4 +27,4 @@ public:
     void run();
     void login();
     void registerCustomer();
-};
+};