Fix PR review comments and refactor menu helper logic

Changes:
- Added name parameter to createTechnician for consistency
- Added function headers for notification-related methods in InventoryManagementService
- Used variables for notification title and message instead of passing strings directly
- Fixed payment reminder notification message formatting
- Moved common helper functions to MenuHelper.h
- Updated CustomerMenu to use shared helper functions instead of duplicate code
- Added missing includes in MenuHelper.h
- Removed redundant helper code from CustomerMenu.cpp
- Minor formatting and comment cleanup

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

@@ -173,9 +173,12 @@
     <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" />

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

@@ -233,6 +233,21 @@
     <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>

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

@@ -1,42 +1,96 @@
 /*
 File: Controller.cpp
-Description: Implements the Controller class which manages authentication, user, service, inventory, payment, and notification operations in the Vehicle Service Management System.
+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
+Date:19-May-2026
 */
-
 #include <stdexcept>
 #include "Controller.h"
+#include "Enums.h"
 #include "User.h"
 
+/*
+Function: login
+Description: Authenticates a user by delegating to the authentication management service.
+Parameter: const std::string& username - user’s username
+           const std::string& password - user’s password
+Return type: bool - true if login successful, false otherwise
+*/
 bool Controller::login(const std::string& username, const std::string& password)
 {
-    return 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)
+void Controller::createTechnician(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone)
 {
 }
 
+/*
+Function: updateUserDetails
+Description: Updates the email and phone details of the currently authenticated user.
+Parameter: const std::string& email - new email address
+           const std::string& phone - new phone number
+Return type: void
+*/
 void Controller::updateUserDetails(const std::string& email, const std::string& phone)
 {
+    User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
+    if (authenticatedUser == nullptr)
+    {
+        throw std::runtime_error("No user currently logged in!");
+    }
+    m_userManagementService.updateUserDetails(authenticatedUser->getId(), email, phone);
 }
 
 util::Map<std::string, const Service*> Controller::getServices()
@@ -49,12 +103,32 @@ util::Map<std::string, const ComboPackage*> Controller::getComboPackages()
     return util::Map<std::string, const ComboPackage*>();
 }
 
+/*
+Function: purchaseService
+Description: Purchases one or more services for a vehicle by delegating to the service management service.
+Parameter: const util::Vector<std::string>& serviceIDs - IDs of services to purchase
+           const std::string& vehicleNumber - vehicle registration number
+           const std::string& vehicleBrand - brand of the vehicle
+           const std::string& vehicleModel - model of the vehicle
+Return type: void
+*/
 void Controller::purchaseService(const util::Vector<std::string>& serviceIDs, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
 {
+    m_serviceManagementService.purchaseService(serviceIDs, vehicleNumber, vehicleBrand, vehicleModel);
 }
 
+/*
+Function: purchaseComboPackage
+Description: Purchases a combo package for a vehicle by delegating to the service management service.
+Parameter: const std::string& comboPackageID - ID of the combo package
+           const std::string& vehicleNumber - vehicle registration number
+           const std::string& vehicleBrand - brand of the vehicle
+           const std::string& vehicleModel - model of the vehicle
+Return type: void
+*/
 void Controller::purchaseComboPackage(const std::string& comboPackageID, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
 {
+    m_serviceManagementService.purchaseComboPackage(comboPackageID, vehicleNumber, vehicleBrand, vehicleModel);
 }
 
 util::Map<std::string, const InventoryItem*> Controller::getInventoryItems()
@@ -215,15 +289,63 @@ void Controller::configureNotifications(bool paymentNotifications, bool serviceN
     }
 }
 
+/*
+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: Executes system checks including sending low stock alerts
-             and payment reminders.
-Parameters: None
+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,18 +1,23 @@
 /*
 File: Controller.h
-Description: File contains the Controller class which manages authentication, user, service, inventory, payment, and notification operations in the Vehicle Service Management System.
+Description: Header file declaring the Controller class, which coordinates
+             authentication, user management, service management, inventory,
+             and notifications across the Vehicle Service System.
 Author: Trenser
-Date: 19-May-2026
+Date:19-May-2026
 */
-
 #pragma once
-#include "Map.h"
 #include <string>
-#include "Enums.h"
 #include "AuthenticationManagementService.h"
+#include "Enums.h"
+#include "InventoryManagementService.h"
+#include "Map.h"
+#include "PaymentManagementService.h"
 #include "ServiceManagementService.h"
 #include "UserManagementService.h"
 #include "InventoryManagementService.h"
+#include "UserManagementService.h"
+#include "ServiceManagementService.h"
 #include "PaymentManagementService.h"
 
 class Service;
@@ -29,16 +34,16 @@ class Controller
 private:
     AuthenticationManagementService m_authenticationManagementService;
     UserManagementService m_userManagementService;
+    ServiceManagementService m_serviceManagementService;
     InventoryManagementService m_inventoryManagementService;
     PaymentManagementService m_paymentManagementService;
-    ServiceManagementService m_serviceManagementService;
 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();
@@ -65,5 +70,7 @@ public:
     util::Vector<const Notification*> getNotifications();
     void deleteNotification(const std::string& notificationID);
     void configureNotifications(bool paymentNotifications, bool serviceNotifications);
+    void loadSystemData();
+    void saveSystemData();
     void runSystemChecks();
 };

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

@@ -8,6 +8,7 @@ Date: 19-May-2026
 #pragma once
 #include <string>
 #include "Map.h"
+#include "Vector.h"
 
 class User;
 class Notification;

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/files/README.md

@@ -0,0 +1 @@
+Place files here.

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

@@ -7,7 +7,12 @@ 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;
 
@@ -41,7 +46,42 @@ ComboPackage::ComboPackage(const std::string& packageName, double discountPercen
     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
@@ -95,6 +135,11 @@ 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.
@@ -158,6 +203,13 @@ Returns:
 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());
+    }
 }
 
 /*
@@ -172,3 +224,118 @@ 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

@@ -8,6 +8,7 @@ Date: 19-May-2026
 #pragma once
 #include <string>
 #include "Map.h"
+#include "Vector.h"
 #include "Enums.h"
 
 class Service;
@@ -19,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);
@@ -34,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

@@ -6,6 +6,10 @@ Author: Trenser
 Date: 19-May-2026
 */
 
+#include <sstream>
+#include <stdexcept>
+#include "Factory.h"
+#include "StringHelper.h"
 #include "InventoryItem.h"
 
 int InventoryItem::m_uid = 0;
@@ -43,6 +47,33 @@ 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.
@@ -172,3 +203,76 @@ 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

@@ -23,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;
@@ -33,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

@@ -7,7 +7,12 @@ 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;
 
@@ -53,7 +58,7 @@ Invoice::Invoice(
     const std::string& bookingId,
     ServiceBooking* booking,
     const util::Timestamp& invoiceDate, 
-    double laborCost, const util::Map<int,
+    double laborCost, const util::Map<std::string,
     InventoryItem*>& parts,
     double partsCost,
     double discountPercentage, 
@@ -73,7 +78,48 @@ 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
@@ -130,13 +176,26 @@ double Invoice::getLaborCost() const
     return m_laborCost;
 }
 
+/*
+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<int, InventoryItem*>& Invoice::getParts() const
+const util::Map<std::string, InventoryItem*>& Invoice::getParts() const
 {
     return m_parts;
 }
@@ -280,9 +339,16 @@ Parameters:
 Returns:
     - void
 */
-void Invoice::setParts(const util::Map<int, InventoryItem*>& parts)
+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());
+    }
 }
 
 /*
@@ -362,3 +428,146 @@ 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

@@ -10,6 +10,7 @@ Date: 19-May-2026
 #pragma once
 #include <string>
 #include "Map.h"
+#include "Vector.h"
 #include "Timestamp.h"
 #include "Enums.h"
 
@@ -25,21 +26,21 @@ 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,
+        double laborCost, const util::Map<std::string,
         InventoryItem*>& parts,
         double partsCost,
         double discountPercentage, 
@@ -48,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;
@@ -65,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

@@ -7,7 +7,12 @@ 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;
 
@@ -25,7 +30,7 @@ JobCard::JobCard()
     m_booking(nullptr),
     m_service(nullptr),
     m_technician(nullptr),
-    m_status(ServiceJobStatus()) {}
+    m_status(util::ServiceJobStatus()) {}
 
 /*
 Function: JobCard
@@ -50,7 +55,7 @@ JobCard::JobCard(const std::string& bookingId,
     const std::string& technicianId,
     User* technician,
     const util::Timestamp& assignedDate,
-    ServiceJobStatus status,
+    util::ServiceJobStatus status,
     const util::Timestamp& completionDate
 )
     : m_id("JC" + std::to_string(++m_uid)),
@@ -64,6 +69,48 @@ 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.
@@ -158,7 +205,7 @@ Description: Retrieves the current status of the job.
 Returns:
     - ServiceJobStatus representing the job status.
 */
-ServiceJobStatus JobCard::getStatus() const
+util::ServiceJobStatus JobCard::getStatus() const
 {
     return m_status;
 }
@@ -286,7 +333,7 @@ Parameters:
 Returns:
     - void
 */
-void JobCard::setStatus(ServiceJobStatus status)
+void JobCard::setStatus(util::ServiceJobStatus status)
 {
     m_status = status;
 }
@@ -303,3 +350,82 @@ 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

@@ -9,13 +9,12 @@ Date: 19-May-2026
 #pragma once
 #include <string>
 #include "Timestamp.h"
+#include "Enums.h"
 
 class ServiceBooking;
 class Service;
 class User;
 
-enum class ServiceJobStatus : int;
-
 class JobCard
 {
 private:
@@ -28,7 +27,7 @@ private:
     std::string m_technicianId;
     User* m_technician;
     util::Timestamp m_assignedDate;
-    ServiceJobStatus m_status;
+    util::ServiceJobStatus m_status;
     util::Timestamp m_completionDate;
 
 public:
@@ -40,7 +39,15 @@ public:
         const std::string& technicianId, 
         User* technician, 
         const util::Timestamp& assignedDate, 
-        ServiceJobStatus status,
+        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;
@@ -51,7 +58,7 @@ public:
     const std::string& getTechnicianId() const;
     User* getTechnician() const;
     const util::Timestamp& getAssignedDate() const;
-    ServiceJobStatus getStatus() const;
+    util::ServiceJobStatus getStatus() const;
     const util::Timestamp& getCompletionDate() const;
     void setId(const std::string& id);
     void setBookingId(const std::string& bookingId);
@@ -61,6 +68,9 @@ public:
     void setTechnicianId(const std::string& technicianId);
     void setTechnician(User* technician);
     void setAssignedDate(const util::Timestamp& assignedDate);
-    void setStatus(ServiceJobStatus status);
+    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

@@ -6,7 +6,10 @@ Author: Trenser
 Date: 19-May-2026
 */
 
+#include <sstream>
 #include "Notification.h"
+#include "StringHelper.h"
+#include "Factory.h"
 
 int Notification::m_uid = 0;
 
@@ -42,6 +45,34 @@ 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.
@@ -185,3 +216,72 @@ 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

@@ -25,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;
@@ -37,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

@@ -7,7 +7,11 @@ 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;
 
@@ -40,7 +44,42 @@ Service::Service(const std::string& name, const util::Map<std::string, Inventory
     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
@@ -64,6 +103,19 @@ 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.
@@ -134,6 +186,13 @@ Returns:
 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());
+    }
 }
 
 /*
@@ -161,3 +220,118 @@ 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

@@ -10,6 +10,7 @@ Date: 19-May-2026
 #pragma once
 #include <string>
 #include "Map.h"
+#include "Vector.h"
 #include "Enums.h"
 
 class InventoryItem;
@@ -20,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;
@@ -36,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,13 +1,18 @@
 /*
 File: ServiceBooking.cpp
-Description: Implements the ServiceBooking class which represents a customer’s service booking in the Vehicle Service Management System.
-             Provides constructors, accessors, and mutators for booking details such as ID, status, services, customer,
-             vehicle information, assigned technician, and discount percentage.
+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
+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;
 
@@ -15,14 +20,13 @@ 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.
+Parameters: None
+Returns: A new ServiceBooking object.
 */
 ServiceBooking::ServiceBooking()
     : m_id("SRV" + std::to_string(++m_uid)),
     m_customer(nullptr),
+    m_assignedTechnician(nullptr),
     m_discountPercentage(0.0) {}
 
 /*
@@ -44,7 +48,6 @@ Returns:
     - A new ServiceBooking object.
 */
 ServiceBooking::ServiceBooking(
-    const std::string& id,
     util::ServiceJobStatus status,
     const util::Map<std::string,
     Service*>& services,
@@ -53,8 +56,6 @@ ServiceBooking::ServiceBooking(
     const std::string& vehicleNumber,
     const std::string& vehicleBrand,
     const std::string& vehicleModel,
-    const std::string& assignedTechnicianId,
-    const std::string& assignedTechnician,
     double discountPercentage
 )
     : m_id("SRV" + std::to_string(++m_uid)),
@@ -65,17 +66,71 @@ 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 ID of the service booking.
-Returns:
-    - const std::string& representing the booking ID.
+Description: Retrieves the unique identifier of the service booking.
+Parameter: None
+Return type: const std::string&
 */
 const std::string& ServiceBooking::getId() const
 {
@@ -85,8 +140,8 @@ const std::string& ServiceBooking::getId() const
 /*
 Function: getStatus
 Description: Retrieves the current status of the service booking.
-Returns:
-    - util::ServiceJobStatus representing the booking status.
+Parameter: None
+Return type: util::ServiceJobStatus
 */
 util::ServiceJobStatus ServiceBooking::getStatus() const
 {
@@ -94,10 +149,23 @@ util::ServiceJobStatus ServiceBooking::getStatus() const
 }
 
 /*
-Function: getServices
-Description: Retrieves the map of services included in the booking.
+Function: getServiceIDs
+Description: Retrieves the IDs of services booked.
+Parameters:
+    - None
 Returns:
-    - const util::Map<std::string, Service*>& representing the services.
+    - 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*>&
 */
 const util::Map<std::string, Service*>& ServiceBooking::getServices() const
 {
@@ -107,8 +175,8 @@ const util::Map<std::string, Service*>& ServiceBooking::getServices() const
 /*
 Function: getCustomerId
 Description: Retrieves the customer ID associated with the booking.
-Returns:
-    - const std::string& representing the customer ID.
+Parameter: None
+Return type: const std::string&
 */
 const std::string& ServiceBooking::getCustomerId() const
 {
@@ -117,9 +185,9 @@ const std::string& ServiceBooking::getCustomerId() const
 
 /*
 Function: getCustomer
-Description: Retrieves the pointer to the associated customer.
-Returns:
-    - User* representing the customer.
+Description: Retrieves the customer object associated with the booking.
+Parameter: None
+Return type: User*
 */
 User* ServiceBooking::getCustomer() const
 {
@@ -128,9 +196,9 @@ User* ServiceBooking::getCustomer() const
 
 /*
 Function: getVehicleNumber
-Description: Retrieves the vehicle registration number.
-Returns:
-    - const std::string& representing the vehicle number.
+Description: Retrieves the vehicle registration number for the booking.
+Parameter: None
+Return type: const std::string&
 */
 const std::string& ServiceBooking::getVehicleNumber() const
 {
@@ -139,9 +207,9 @@ const std::string& ServiceBooking::getVehicleNumber() const
 
 /*
 Function: getVehicleBrand
-Description: Retrieves the brand of the vehicle.
-Returns:
-    - const std::string& representing the vehicle brand.
+Description: Retrieves the brand of the vehicle for the booking.
+Parameter: None
+Return type: const std::string&
 */
 const std::string& ServiceBooking::getVehicleBrand() const
 {
@@ -150,9 +218,9 @@ const std::string& ServiceBooking::getVehicleBrand() const
 
 /*
 Function: getVehicleModel
-Description: Retrieves the model of the vehicle.
-Returns:
-    - const std::string& representing the vehicle model.
+Description: Retrieves the model of the vehicle for the booking.
+Parameter: None
+Return type: const std::string&
 */
 const std::string& ServiceBooking::getVehicleModel() const
 {
@@ -161,9 +229,9 @@ const std::string& ServiceBooking::getVehicleModel() const
 
 /*
 Function: getAssignedTechnicianId
-Description: Retrieves the ID of the assigned technician.
-Returns:
-    - const std::string& representing the technician ID.
+Description: Retrieves the ID of the technician assigned to the booking.
+Parameter: None
+Return type: const std::string&
 */
 const std::string& ServiceBooking::getAssignedTechnicianId() const
 {
@@ -172,20 +240,19 @@ const std::string& ServiceBooking::getAssignedTechnicianId() const
 
 /*
 Function: getAssignedTechnician
-Description: Retrieves the name of the assigned technician.
-Returns:
-    - const std::string& representing the technician name.
+Description: Retrieves the technician object assigned to the booking.
+Parameter: None
+Return type: User*
 */
-const std::string& ServiceBooking::getAssignedTechnician() const
+User* ServiceBooking::getAssignedTechnician() const
 {
     return m_assignedTechnician;
 }
-
 /*
 Function: getDiscountPercentage
 Description: Retrieves the discount percentage applied to the booking.
-Returns:
-    - double representing the discount percentage.
+Parameter: None
+Return type: double
 */
 double ServiceBooking::getDiscountPercentage() const
 {
@@ -194,11 +261,9 @@ double ServiceBooking::getDiscountPercentage() const
 
 /*
 Function: setId
-Description: Sets the unique ID of the service booking.
-Parameters:
-    - id: New booking ID string.
-Returns:
-    - void
+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)
 {
@@ -208,10 +273,8 @@ void ServiceBooking::setId(const std::string& id)
 /*
 Function: setStatus
 Description: Sets the current status of the service booking.
-Parameters:
-    - status: New booking status value.
-Returns:
-    - void
+Parameter: const util::ServiceJobStatus& status - new booking status
+Return type: void
 */
 void ServiceBooking::setStatus(const util::ServiceJobStatus& status)
 {
@@ -220,24 +283,27 @@ void ServiceBooking::setStatus(const util::ServiceJobStatus& status)
 
 /*
 Function: setServices
-Description: Sets the services included in the booking.
-Parameters:
-    - services: Map of services.
-Returns:
-    - void
+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 associated with the booking.
-Parameters:
-    - customerId: New customer ID string.
-Returns:
-    - void
+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)
 {
@@ -246,11 +312,9 @@ void ServiceBooking::setCustomerId(const std::string& customerId)
 
 /*
 Function: setCustomer
-Description: Sets the pointer to the associated customer.
-Parameters:
-    - customer: Pointer to the User object.
-Returns:
-    - void
+Description: Sets the customer object for the booking.
+Parameter: User* customer - pointer to the customer object
+Return type: void
 */
 void ServiceBooking::setCustomer(User* customer)
 {
@@ -259,11 +323,9 @@ void ServiceBooking::setCustomer(User* customer)
 
 /*
 Function: setVehicleNumber
-Description: Sets the vehicle registration number.
-Parameters:
-    - vehicleNumber: New vehicle number string.
-Returns:
-    - void
+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)
 {
@@ -272,11 +334,9 @@ void ServiceBooking::setVehicleNumber(const std::string& vehicleNumber)
 
 /*
 Function: setVehicleBrand
-Description: Sets the brand of the vehicle.
-Parameters:
-    - vehicleBrand: New vehicle brand string.
-Returns:
-    - void
+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)
 {
@@ -285,11 +345,9 @@ void ServiceBooking::setVehicleBrand(const std::string& vehicleBrand)
 
 /*
 Function: setVehicleModel
-Description: Sets the model of the vehicle.
-Parameters:
-    - vehicleModel: New vehicle model string.
-Returns:
-    - void
+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)
 {
@@ -298,11 +356,9 @@ void ServiceBooking::setVehicleModel(const std::string& vehicleModel)
 
 /*
 Function: setAssignedTechnicianId
-Description: Sets the ID of the assigned technician.
-Parameters:
-    - assignedTechnicianId: New technician ID string.
-Returns:
-    - void
+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)
 {
@@ -311,26 +367,149 @@ void ServiceBooking::setAssignedTechnicianId(const std::string& assignedTechnici
 
 /*
 Function: setAssignedTechnician
-Description: Sets the name of the assigned technician.
-Parameters:
-    - assignedTechnician: New technician name string.
-Returns:
-    - void
+Description: Sets the technician object assigned to the booking.
+Parameter: User* assignedTechnician - pointer to the technician object
+Return type: void
 */
-void ServiceBooking::setAssignedTechnician(const std::string& assignedTechnician)
+void ServiceBooking::setAssignedTechnician(User* assignedTechnician)
 {
     m_assignedTechnician = assignedTechnician;
 }
 
 /*
 Function: setDiscountPercentage
-Description: Sets the discount percentage applied to the booking.
-Parameters:
-    - discountPercentage: New discount percentage value.
-Returns:
-    - void
+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,14 +1,15 @@
 /*
 File: ServiceBooking.h
-Description: Declares the ServiceBooking class which represents a customer’s service booking in the Vehicle Service Management System.
-             Each booking includes a unique ID, status, associated services, customer details, vehicle information, assigned technician, and discount percentage.
+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
+Date:19-May-2026
 */
-
 #pragma once
 #include <string>
 #include "Map.h"
+#include "Vector.h"
 #include "Enums.h"
 
 class Service;
@@ -20,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;
@@ -27,12 +29,11 @@ private:
     std::string m_vehicleBrand;
     std::string m_vehicleModel;
     std::string m_assignedTechnicianId;
-    std::string 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,
@@ -41,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 std::string& 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;
@@ -54,7 +65,7 @@ public:
     const std::string& getVehicleBrand() const;
     const std::string& getVehicleModel() const;
     const std::string& getAssignedTechnicianId() const;
-    const std::string& getAssignedTechnician() const;
+    User* getAssignedTechnician() const;
     double getDiscountPercentage() const;
     void setId(const std::string& id);
     void setStatus(const util::ServiceJobStatus& status);
@@ -65,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 std::string& 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

@@ -7,9 +7,12 @@ 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;
 
@@ -50,6 +53,39 @@ User::User(const std::string& userName, const std::string& password, const std::
     m_type(role),
     m_status(util::State::ACTIVE) {}
 
+/*
+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)
+{
+    int idNumber = util::extractNumber(m_id);
+    if (idNumber > m_uid)
+    {
+        m_uid = idNumber;
+    }
+}
+
 /*
 Function: ~User
 Description: Destructor that cleans up dynamically allocated notifications associated with the user.
@@ -60,9 +96,10 @@ Returns:
 */
 User::~User()
 {
-    for (int index = 0; index < m_notifications.getSize(); index++)
+    auto values = m_notifications.getValues();
+    for (int index = 0; index < values.getSize(); index++)
     {
-        delete m_notifications.getValues()[index];
+        delete values[index];
     }
 }
 
@@ -284,3 +321,71 @@ void User::setState(util::State status)
 {
     m_status = status;
 }
+
+/*
+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

@@ -31,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;
@@ -50,4 +51,7 @@ public:
     void addNotification(Notification* notification) override;
     void setRole(util::UserType role);
     void setState(util::State status);
+    std::string serialize() const;
+    static User* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

@@ -1,3 +1,81 @@
+/*
+File: AuthenticationManagementService.cpp
+Description: Implementation file containing the method definitions of the
+			 AuthenticationManagementService class, including login, logout,
+			 password change, and retrieval of the authenticated user.
+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,11 +1,11 @@
 /*
 File: AuthenticationManagementService.h
-Description: Declares the AuthenticationManagementService class which manages user authentication in the Vehicle Service Management System.
-             Provides functionality for login, logout, password change, and retrieving the currently authenticated user.
+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
+Date:19-May-2026
 */
-
 #pragma once
 #include <string>
 #include "DataStore.h"

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

@@ -1,15 +1,35 @@
+/*
+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 "InventoryManagementService.h"
-#include "Vector.h"
-#include "Enums.h"
-#include "InventoryItem.h"
 #include "Config.h"
-#include "User.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: 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)
@@ -22,6 +42,14 @@ void InventoryManagementService::attach(User* 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)
@@ -34,6 +62,18 @@ void InventoryManagementService::detach(User* user)
 	}
 }
 
+/*
+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)
@@ -60,20 +100,39 @@ void InventoryManagementService::sendNotification(User* user, const std::string&
 	}
 }
 
+/*
+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],
-			"Low Stock Alert",
-			"The inventory item with ID " + inventoryItem->getId() +
-			" has very low quantity in the inventory"
+			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();
@@ -103,3 +162,92 @@ void InventoryManagementService::sendLowStockAlerts()
 		}
 	}
 }
+
+/*
+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);
+}

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

@@ -9,6 +9,7 @@ Date: 19-May-2026
 #pragma once
 #include <string>
 #include "Map.h"
+#include "Vector.h"
 #include "NotificationManagementService.h"
 #include "DataStore.h"
 
@@ -19,6 +20,7 @@ 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();
@@ -29,4 +31,8 @@ public:
     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

@@ -19,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

@@ -8,14 +8,16 @@ Date: 20-May-2026
 */
 
 #include <stdexcept>
-#include "PaymentManagementService.h"
-#include "Invoice.h"
-#include "ServiceBooking.h"
-#include "Enums.h"
-#include "Timestamp.h"
 #include "Config.h"
-#include "User.h"
+#include "Enums.h"
 #include "Factory.h"
+#include "FileManager.h"
+#include "Invoice.h"
+#include "PaymentManagementService.h"
+#include "ServiceBooking.h"
+#include "Timestamp.h"
+#include "User.h"
+#include "Utility.h"
 
 util::Map<std::string, User*> PaymentManagementService::m_observers{};
 
@@ -125,12 +127,129 @@ void PaymentManagementService::sendPaymentReminders()
 					User* customer = serviceBooking->getCustomer();
 					if (customer)
 					{
-						sendNotification(customer,
-							"Payment Reminder",
-							"Your payment for Invoice ID " + invoice->getId() + " is still pending.Please complete the payment." + invoice->getId());
+						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);
+}

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

@@ -22,6 +22,7 @@ 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);
@@ -31,4 +32,8 @@ public:
     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,17 +1,108 @@
 /*
 File: ServiceManagementService.cpp
-Description: Implements the ServiceManagementService class which manages service-related operations
-			 in the Vehicle Service Management System. Provides functionality for attaching/detaching observers
-			 and sending notifications to users regarding service events.
+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: 20-May-2026
+Date:19-May-2026
 */
 
 #include <stdexcept>
-#include "ServiceManagementService.h"
-#include "User.h"
+#include "AuthenticationManagementService.h"
+#include "ComboPackage.h"
+#include "Config.h"
 #include "Factory.h"
+#include "FileManager.h"
+#include "JobCard.h"
+#include "Service.h"
+#include "ServiceBooking.h"
+#include "ServiceManagementService.h"
 #include "Timestamp.h"
+#include "User.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::STARTED, 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::STARTED, 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{};
 
@@ -92,3 +183,320 @@ void ServiceManagementService::sendNotification(User* user, const std::string& t
 		}
 	}
 }
+
+/*
+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);
+}

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

@@ -1,12 +1,11 @@
 /*
 File: ServiceManagementService.h
-Description: Declares the ServiceManagementService class which manages services, combo packages, service bookings, and job cards
-             in the Vehicle Service Management System. Provides functionality to purchase services or packages, create and remove
-             services, assign and complete jobs, cancel bookings, and handle notifications using the Observer pattern.
+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
+Date:19-May-2026
 */
-
 #pragma once
 #include <string>
 #include "Map.h"
@@ -23,6 +22,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();
@@ -43,4 +43,14 @@ public:
     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,17 +1,120 @@
 /*
 File: UserManagementService.cpp
-Description: Implements the UserManagementService class which manages user-related operations
-			 in the Vehicle Service Management System. Provides functionality for retrieving user notifications
-			 and deleting notifications by ID.
+Description: Implementation file containing the method definitions of the
+			 UserManagementService class, including user creation, updates,
+			 and ensuring an admin account exists.
 Author: Trenser
-Date: 20-May-2026
+Date:19-May-2026
 */
-
 #include <stdexcept>
-#include "UserManagementService.h"
+#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"
 
+
+/*
+Function: ensureAdminExists
+Description: Ensures that at least one admin user exists in the system.
+			 If no admin is found, creates a default admin user using
+			 configuration constants.
+Parameter: None
+Return type: void
+*/
+void UserManagementService::ensureAdminExists()
+{
+	auto& usersMap = m_dataStore.getUsers();
+	int usersMapSize = usersMap.getSize();
+	bool isAdminFound = false;
+	for (int index = 0; index < usersMapSize; index++)
+	{
+		User* user = usersMap.getValueAt(index);
+		if (user && user->getUserType() == util::UserType::ADMIN)
+		{
+			isAdminFound = true;
+			break;
+		}
+	}
+	if (!isAdminFound)
+	{
+		createUser(
+			config::admin::DEFAULT_ADMIN_USERNAME,
+			config::admin::DEFAULT_ADMIN_NAME,
+			config::admin::DEFAULT_ADMIN_PASSWORD,
+			config::admin::DEFAULT_ADMIN_EMAIL,
+			config::admin::DEFAULT_ADMIN_PHONE, 
+			util::UserType::ADMIN);
+	}
+}
+
+/*
+Function: createUser
+Description: Creates a new user with the provided details. Validates that
+			 the username is unique, then attaches the user to relevant
+			 management services (payment, service, inventory).
+Parameter: const std::string& username - user’s username
+		   const std::string& name - user’s name
+		   const std::string& password - user’s password
+		   const std::string& email - user’s email address
+		   const std::string& phone - user’s phone number
+		   util::UserType type - type of user (ADMIN, CUSTOMER, TECHNICIAN)
+Return type: void
+*/
+void UserManagementService::createUser(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone, util::UserType type)
+{
+	InventoryManagementService inventoryManagementService;
+	PaymentManagementService paymentManagementService;
+	ServiceManagementService serviceManagementService;
+	auto& usersMap = m_dataStore.getUsers();
+	int index = usersMap.findIf(
+		[&](const std::string&, User* user)
+		{
+			return user->getUserName() == username;
+		}
+	);
+	if (index != -1)
+	{
+		throw std::runtime_error("Username already exists");
+	}
+	User* newUser = Factory::getObject<User>(username, password, name, phone, email, type);
+	usersMap.insert(newUser->getId(), newUser);
+	paymentManagementService.attach(newUser);
+	serviceManagementService.attach(newUser);
+	if (newUser->getUserType() == util::UserType::ADMIN)
+	{
+		inventoryManagementService.attach(newUser);
+	}
+}
+
+/*
+Function: updateUserDetails
+Description: Updates the email and phone details of an existing user.
+			 Throws an exception if the user does not exist.
+Parameter: const std::string& userID - ID of the user to update
+		   const std::string& email - new email address
+		   const std::string& phone - new phone number
+Return type: void
+*/
+void UserManagementService::updateUserDetails(const std::string& userID, const std::string& email, const std::string& phone)
+{
+	auto& usersMap = m_dataStore.getUsers();
+	int index = usersMap.find(userID);
+	if (index == -1)
+	{
+		throw std::runtime_error("User does not exist!");
+	}
+	User* user = usersMap.getValueAt(index);
+	user->setEmail(email);
+	user->setPhone(phone);
+}
+
 /*
 Function: getUserNotifications
 Description: Retrieves all notifications associated with a given user ID.
@@ -73,3 +176,71 @@ void UserManagementService::deleteNotification(const std::string& 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);
+}

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

@@ -1,11 +1,11 @@
 /*
 File: UserManagementService.h
-Description: Declares the UserManagementService class which manages user-related operations in the Vehicle Service Management System.
-             Provides functionality to create, update, retrieve, and remove users, as well as manage user notifications.
+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
+Date:19-May-2026
 */
-
 #pragma once
 #include <string>
 #include "Map.h"
@@ -21,7 +21,7 @@ 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);
@@ -29,4 +29,7 @@ public:
     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

@@ -1,7 +1,8 @@
 /*
 File: Config.h
-Description: Defines configuration constants for system thresholds in the Vehicle Service Management System.
-			 Includes limits for inventory stock alerts and payment reminder intervals.
+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
 */
@@ -10,9 +11,33 @@ Date: 21-May-2026
 
 namespace config
 {
+	namespace admin
+	{
+		constexpr const char* DEFAULT_ADMIN_USERNAME = "admin";
+		constexpr const char* DEFAULT_ADMIN_NAME = "admin";
+		constexpr const char* DEFAULT_ADMIN_PASSWORD = "";
+		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

@@ -236,9 +236,9 @@ namespace util
         switch (status)
         {
         case State::ACTIVE:
-            return "STARTED";
+            return "ACTIVE";
         case State::INACTIVE:
-            return "COMPLETED";
+            return "INACTIVE";
         }
         throw std::invalid_argument("Invalid State");
     }
@@ -259,7 +259,7 @@ namespace util
         {
             return State::ACTIVE;
         }
-        if (value == "COMPLETED")
+        if (value == "INACTIVE")
         {
             return State::INACTIVE;
         }

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

@@ -0,0 +1,79 @@
+/*
+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 "Vector.h"
+
+namespace util
+{
+    /*
+    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())
+        {
+            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,117 @@
+/*
+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"
+
+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())
+		{
+			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;
     }
 
     /*

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

@@ -1,8 +1,103 @@
 /*
 File: Utility.h
-Description:
+Description: Header file declaring utility functions used across the system,
+             including cost calculation for services and combo packages.
 Author: Trenser
-Date: 20-May-2026
+Date:19-May-2026
 */
 
 #pragma once
+#include "DataStore.h"
+#include "FileHelper.h"
+#include "InventoryItem.h"
+#include "NotificationManagementService.h"
+#include "Service.h"
+#include "ComboPackage.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/views/CustomerMenu.cpp

@@ -1,41 +1,54 @@
 /*
 File: CustomerMenu.cpp
-Description: Implements the CustomerMenu class which provides the customer’s console interface
-             in the Vehicle Service Management System. Handles menu display, user input, and
-             customer-specific operations such as booking services, viewing history, managing payments,
-             invoices, and notifications.
+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
+Date:19-May-2026
 */
-
+#include <iomanip>
+#include "ComboPackage.h"
 #include "CustomerMenu.h"
 #include "InputHelper.h"
-#include "OutputHelper.h"
+#include "InventoryItem.h"
+#include "Map.h"
 #include "MenuHelper.h"
+#include "OutputHelper.h"
+#include "Service.h"
+#include "Validator.h"
+#include "Vector.h"
 
 /*
 Function: showMenu
-Description: Displays the customer menu in a loop until the user chooses to logout.
-             Handles exceptions and ensures smooth user interaction.
-Parameters:
-    - None
-Returns:
-    - void
+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)
+    while (true)
     {
         try
         {
             int choice;
             util::clear();
-			std::cout << "" << std::endl;
+            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))
             {
-				isMenuActive = false;
+                break;
             }
         }
         catch (const std::exception& e)
@@ -46,29 +59,168 @@ void CustomerMenu::showMenu()
     }
 }
 
+/*
+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)
 {
+    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 << "Enter new email: ";
+	util::read(email);
+	if (!util::isEmailValid(email))
+	{
+		std::cout << "Error: Email is invalid!";
+		util::pressEnter();
+		return;
+	}
+	std::cout << "Enter new phone: ";
+	util::read(phone);
+	if (!util::isPhoneNumberValid(phone))
+	{
+		std::cout << "Error: Phone number is invalid!";
+		util::pressEnter();
+		return;
+	}
+	m_controller.updateUserDetails(email, phone);
+	std::cout << "Profile details updated successfully";
+	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;
+	auto services = m_controller.getServices();
+    util::Vector<std::string> selectedServices;
+    util::clear();
+    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 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;
+    auto comboPackages = m_controller.getComboPackages();
+    util::clear();
+    const ComboPackage* selectedComboPackage = selectComboPackageFromPackages(comboPackages);
+    if (selectedComboPackage == nullptr)
+    {
+        std::cout << "Failed to book combo package!";
+        util::pressEnter();
+        return;
+    }
+    util::clear();
+    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";
+    util::pressEnter();
 }
 
 void CustomerMenu::viewServiceHistory()
@@ -96,38 +248,6 @@ void CustomerMenu::viewNotifications()
 	viewAndDeleteNotification(m_controller);
 }
 
-/*
-Function: getNotificationPreference (static helper)
-Description: Helper function to configure notification preferences for a specific service.
-Parameters:
-    - serviceName: Name of the service for which notifications are being configured.
-Returns:
-    - bool: True if notifications are enabled, False if disabled.
-*/
-static bool getNotificationPreference(const std::string& serviceName)
-{
-    int choice;
-    while (true)
-    {
-        util::clear();
-        std::cout << "    Configure Notification Preferences\n";
-        std::cout << "\n" << serviceName << " Notifications\n";
-        std::cout << "1. Enable Notifications\n";
-        std::cout << "2. Disable Notifications\n";
-        std::cout << "Enter your choice: ";
-        util::read(choice);
-        if (choice == 1)
-        {
-            return true;
-        }
-        if (choice == 2)
-        {
-            return false;
-        }
-        std::cout << "\nInvalid choice. Please enter 1 or 2.\n";
-        util::pressEnter();
-    }
-}
 
 /*
 Function: configureNotifications

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

@@ -1,10 +1,11 @@
 /*
 File: CustomerMenu.h
-Description: Declares the CustomerMenu class which provides the customer-facing console menu in the Vehicle Service Management System.
-             Supports operations such as account management, service selection, combo package booking, viewing service history,
-             handling payments and invoices, and managing notifications.
+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
+Date:19-May-2026
 */
 
 #pragma once

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

@@ -1,29 +1,33 @@
 /*
 File: MenuHelper.h
-Description: Provides inline utility functions to support menu operations in the Vehicle Service Management System.
-             Includes helper functions for selecting, displaying, and managing notifications, as well as
-             integrating with the controller for user interactions.
+Description: Header file declaring the MenuHelper class, which provides
+             utility functions for menu-driven operations such as
+             notification selection and display.
 Author: Trenser
 Date: 21-May-2026
 */
 
 #pragma once
 #include <iomanip>
-#include "Vector.h"
+#include <string>
 #include "Controller.h"
-#include "Notification.h"
 #include "InputHelper.h"
+#include "Map.h"
+#include "Notification.h"
 #include "OutputHelper.h"
+#include "Vector.h"
+#include "Validator.h"
+#include "Service.h"
+#include "ComboPackage.h"
+#include "Utility.h"
 
 /*
 Function: selectNotification
-Description: Displays a list of notifications with index, ID, title, and timestamp,
-             then allows the user to select one by index.
-Parameters:
-    - notifications: Vector of Notification pointers to be displayed.
-Returns:
-    - const Notification* representing the selected notification.
-    - nullptr if no notifications are available or if the selection is invalid.
+Description: Displays a list of notifications with index, ID, title, and timestamp.
+             Allows the user to select a notification by index. Returns the selected
+             notification or nullptr if the selection is invalid.
+Parameter: const util::Vector<const Notification*>& notifications - list of notifications
+Return type: const Notification* - pointer to the selected notification
 */
 inline const Notification* selectNotification(const util::Vector<const Notification*>& notifications)
 {
@@ -112,3 +116,172 @@ inline void viewAndDeleteNotification(Controller& controller)
     controller.deleteNotification(selectedNotification->getId());
     util::pressEnter();
 }
+
+/*
+Function: changePassword
+Description: Helper function to change password
+Parameter: controller: Reference to the Controller object used to manage notifications.
+Return type: void
+*/
+inline void changePasswordHelper(Controller& controller)
+{
+    std::string newPassword;
+    while (true)
+    {
+        util::clear();
+        std::cout << "Enter new password: ";
+        util::read(newPassword);
+        if (!util::isPasswordValid(newPassword))
+        {
+            std::cout << "Error: Password is not strong enough!\n";
+            util::pressEnter();
+            continue;
+        }
+        controller.changePassword(newPassword);
+        std::cout << "Password changed successfully\n";
+        util::pressEnter();
+        break;
+    }
+}
+
+/*
+Function: selectServiceFromServices
+Description: Displays active services and allows the customer to select one by index.
+Parameter: const util::Map<std::string, const Service*>& services - list of services
+Return type: const Service* - selected service
+*/
+inline const Service* selectServiceFromServices(const util::Map<std::string, const Service*>& services)
+{
+    util::Map<int, const Service*> activeServicesMap;
+    int currentIndex = 1;
+    int userInputIndex;
+    std::cout << std::left
+        << std::setw(10) << "Index"
+        << std::setw(15) << "Service ID"
+        << std::setw(25) << "Service Name"
+        << std::setw(15) << "Estimated Cost"
+        << std::endl;
+    for (int index = 0; index < services.getSize(); index++)
+    {
+        const Service* currentService = services.getValueAt(index);
+        if (currentService->getState() != util::State::ACTIVE)
+        {
+            continue;
+        }
+        activeServicesMap.insert(currentIndex, currentService);
+        double partsCost = util::calculatePartsCost(currentService);
+        std::cout << std::left
+            << std::setw(10) << currentIndex
+            << std::setw(15) << currentService->getId()
+            << std::setw(25) << currentService->getName()
+            << std::setw(15) << (currentService->getLaborCost() + partsCost)
+            << std::endl;
+        currentIndex++;
+    }
+    if (activeServicesMap.getSize() == 0)
+    {
+        std::cout << "No active services available." << std::endl;
+        return nullptr;
+    }
+    std::cout << "Enter service index: ";
+    util::read(userInputIndex);
+    if (activeServicesMap.find(userInputIndex) == -1)
+    {
+        std::cout << "Invalid service index." << std::endl;
+        return nullptr;
+    }
+    return activeServicesMap[userInputIndex];
+}
+
+/*
+Function: selectComboPackageFromPackages
+Description: Displays active combo packages and allows the customer to select one by index.
+Parameter: const util::Map<std::string, const ComboPackage*>& comboPackages - list of combo packages
+Return type: const ComboPackage* - selected combo package
+*/
+inline const ComboPackage* selectComboPackageFromPackages(const util::Map<std::string, const ComboPackage*>& comboPackages)
+{
+    util::Map<int, const ComboPackage*> activeComboPackages;
+    int currentIndex = 1;
+    int userInputIndex;
+    std::cout << std::left
+        << std::setw(10) << "Index"
+        << std::setw(15) << "Combo Package ID"
+        << std::setw(15) << "Combo Package Name"
+        << std::setw(15) << "Estimate Cost"
+        << std::endl;
+    for (int index = 0; index < comboPackages.getSize(); index++)
+    {
+        const ComboPackage* currentComboPackage = comboPackages.getValueAt(index);
+        if (currentComboPackage->getState() != util::State::ACTIVE)
+        {
+            continue;
+        }
+        activeComboPackages.insert(currentIndex, currentComboPackage);
+        std::cout << std::left
+            << std::setw(10) << currentIndex
+            << std::setw(15) << currentComboPackage->getId()
+            << std::setw(25) << currentComboPackage->getPackageName()
+            << std::setw(15) << util::calculateComboServiceEstimatedCost(currentComboPackage)
+            << std::endl;
+        currentIndex++;
+    }
+    if (activeComboPackages.getSize() == 0)
+    {
+        std::cout << "No active combo packages available." << std::endl;
+        return nullptr;
+    }
+    std::cout << "Enter combo package index: ";
+    util::read(userInputIndex);
+    if (activeComboPackages.find(userInputIndex) == -1)
+    {
+        std::cout << "Invalid combo package index." << std::endl;
+        return nullptr;
+    }
+    return activeComboPackages[userInputIndex];
+}
+
+/*
+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
+*/
+
+/*
+Function: getNotificationPreference (static helper)
+Description: Helper function to configure notification preferences for a specific service.
+Parameters:
+    - serviceName: Name of the service for which notifications are being configured.
+Returns:
+    - bool: True if notifications are enabled, False if disabled.
+*/
+inline bool getNotificationPreference(const std::string& serviceName)
+{
+    int choice;
+    while (true)
+    {
+        util::clear();
+        std::cout << "    Configure Notification Preferences\n";
+        std::cout << "\n" << serviceName << " Notifications\n";
+        std::cout << "1. Enable Notifications\n";
+        std::cout << "2. Disable Notifications\n";
+        std::cout << "Enter your choice: ";
+        util::read(choice);
+        if (choice == 1)
+        {
+            return true;
+        }
+        if (choice == 2)
+        {
+            return false;
+        }
+        std::cout << "\nInvalid choice. Please enter 1 or 2.\n";
+        util::pressEnter();
+    }
+}
+

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

@@ -1,26 +1,29 @@
 /*
 File: UserInterface.cpp
-Description: Implements the UserInterface class which provides the main entry point for the Vehicle Service Management System.
-			 Handles system checks, displays the main menu, and manages user operations such as login and customer registration.
+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
-*/
+Date:19-May-2026
 
+*/
 #include "UserInterface.h"
 #include "InputHelper.h"
 #include "OutputHelper.h"
+#include "Enums.h"
+#include "User.h"
+#include "Validator.h"
 
 /*
 Function: run
-Description: Runs the Vehicle Service Management System interface.
-			 Performs system checks, displays the main menu, and processes user input until exit.
-Parameters:
-	- None
-Returns:
-	- void
+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()
 {
+	m_controller.loadSystemData();
 	m_controller.runSystemChecks();
 	bool isMenuActive = true;
 	while (isMenuActive)
@@ -42,15 +45,14 @@ void UserInterface::run()
 			util::pressEnter();
 		}
 	}
+	m_controller.saveSystemData();
 }
 
 /*
 Function: handleOperation
-Description: Processes the user’s menu choice and executes the corresponding action.
-Parameters:
-	- choice: Integer representing the selected menu option.
-Returns:
-	- bool: True if the menu should remain active, False if exit is selected.
+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)
 {
@@ -74,26 +76,88 @@ bool UserInterface::handleOperation(int choice)
 
 /*
 Function: login
-Description: Handles the login process for existing users.
-Parameters:
-	- None
-Returns:
-	- void
+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 << "Enter username: ";
+	util::read(username);
+	std::cout << "Enter password: ";
+	util::read(password);
+	if (m_controller.login(username, password))
+	{
+		const User* authenticatedUser = m_controller.getAuthenticatedUser();
+		if (authenticatedUser != nullptr)
+		{
+			switch (authenticatedUser->getUserType())
+			{
+			case util::UserType::ADMIN:
+				m_adminMenu.showMenu();
+				break;
+			case util::UserType::TECHNICIAN:
+				m_technicianMenu.showMenu();
+				break;
+			case util::UserType::CUSTOMER:
+				m_customerMenu.showMenu();
+				break;
+			default:
+				std::cout << "\nError: Unknown user type";
+				break;
+			}
+		}
+	}
+	else
+	{
+		std::cout << "\nError: Invalid Username or Password";
+	}
 }
 
 /*
 Function: registerCustomer
-Description: Handles the registration process for new customers.
-Parameters:
-	- None
-Returns:
-	- void
+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 << "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,12 +1,12 @@
 /*
 File: UserInterface.h
-Description: Declares the UserInterface class which provides the main console interface for the Vehicle Service Management System.
-             Handles user interactions such as login, customer registration, and role-based menu navigation
-             for Admin, Technician, and Customer modules.
+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
+Date:19-May-2026
 */
-
 #pragma once
 #include "Controller.h"
 #include "AdminMenu.h"