Merged PR 1152: Vehicle Service System v1.0.0.0

Features Included:

Secure access and session management with role-based authentication
Customer and technician account management
Service booking and technician assignment
Service and combo package management
Job card tracking and completion workflow
Inventory management and stock monitoring
Invoice generation and payment processing
Notification management with configurable preferences
Observer pattern based alerts for inventory, payments, and service updates

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

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

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

@@ -171,15 +171,21 @@
     <ClInclude Include="services\PaymentManagementService.h" />
     <ClInclude Include="services\ServiceManagementService.h" />
     <ClInclude Include="services\UserManagementService.h" />
+    <ClInclude Include="utilities\Config.h" />
     <ClInclude Include="utilities\Enums.h" />
+    <ClInclude Include="utilities\FileHelper.h" />
+    <ClInclude Include="utilities\FileManager.h" />
     <ClInclude Include="utilities\InputHelper.h" />
     <ClInclude Include="utilities\Map.h" />
     <ClInclude Include="utilities\OutputHelper.h" />
+    <ClInclude Include="utilities\StringHelper.h" />
     <ClInclude Include="utilities\Timestamp.h" />
+    <ClInclude Include="utilities\Utility.h" />
     <ClInclude Include="utilities\Validator.h" />
     <ClInclude Include="utilities\Vector.h" />
     <ClInclude Include="views\AdminMenu.h" />
     <ClInclude Include="views\CustomerMenu.h" />
+    <ClInclude Include="views\MenuHelper.h" />
     <ClInclude Include="views\TechnicianMenu.h" />
     <ClInclude Include="views\UserInterface.h" />
   </ItemGroup>

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

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

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

@@ -1,147 +1,617 @@
+/*
+File: Controller.cpp
+Description: Implementation file containing the method definitions of the
+             Controller class, including authentication, user creation,
+             service purchasing, and system checks.
+Author: Trenser
+Date:19-May-2026
+*/
+#include "ComboPackage.h"
 #include "Controller.h"
+#include "Enums.h"
+#include "InventoryItem.h"
+#include "Invoice.h"
+#include "JobCard.h"
+#include "Service.h"
+#include "ServiceBooking.h"
+#include "User.h"
+#include <stdexcept>
 
+/*
+Function: login
+Description: Authenticates a user by delegating to the authentication management service.
+Parameter: const std::string& username - user’s username
+           const std::string& password - user’s password
+Return type: bool - true if login successful, false otherwise
+*/
 bool Controller::login(const std::string& username, const std::string& password)
 {
-    return false;
+    return m_authenticationManagementService.login(username, password);
 }
 
+/*
+Function: logout
+Description: Logs out the currently authenticated user.
+Parameter: None
+Return type: void
+*/
 void Controller::logout()
 {
+    m_authenticationManagementService.logout();
 }
 
+/*
+Function: changePassword
+Description: Changes the password of the currently authenticated user.
+Parameter: const std::string& newPassword - new password to set
+Return type: void
+*/
 void Controller::changePassword(const std::string& newPassword)
 {
+    m_authenticationManagementService.changePassword(newPassword);
 }
 
-void Controller::createCustomer(const std::string& username, const std::string& password, const std::string& email, const std::string& phone)
+/*
+Function: createCustomer
+Description: Creates a new customer account with the provided details.
+Parameter: const std::string& username - customer’s username
+           const std::string& name - customer’s name
+           const std::string& password - customer’s password
+           const std::string& email - customer’s email
+           const std::string& phone - customer’s phone number
+Return type: void
+*/
+
+void Controller::createCustomer(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone)
 {
+    m_userManagementService.createUser(username, name, password, email, phone, util::UserType::CUSTOMER);
 }
 
+/*
+Function: getAuthenticatedUser
+Description: Retrieves the currently authenticated user.
+Parameter: None
+Return type: const User* - pointer to the authenticated user
+*/
 const User* Controller::getAuthenticatedUser()
 {
-    return nullptr;
+    return m_authenticationManagementService.getAuthenticatedUser();
 }
 
-void Controller::createTechnician(const std::string& username, const std::string& password, const std::string& email, const std::string& phone)
+/*
+Function: createTechnician
+Description: Creates a new technician account with provided details by
+             delegating to the user management service.
+Parameter: const std::string& username - technician's username
+           const std::string& password - technician's password
+           const std::string& email - technician's email address
+           const std::string& phoneNumber - technician's phone number
+Return type: void
+*/
+void Controller::createTechnician(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phoneNumber)
 {
+    m_userManagementService.createUser(username, name, password, email, phoneNumber, util::UserType::TECHNICIAN);
 }
 
+/*
+Function: updateUserDetails
+Description: Updates the email and phone details of the currently authenticated user.
+Parameter: const std::string& email - new email address
+           const std::string& phone - new phone number
+Return type: void
+*/
 void Controller::updateUserDetails(const std::string& email, const std::string& phone)
 {
+    User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
+    if (authenticatedUser == nullptr)
+    {
+        throw std::runtime_error("No user currently logged in!");
+    }
+    m_userManagementService.updateUserDetails(authenticatedUser->getId(), email, phone);
 }
 
+/*
+Function: getServices
+Description: Retrieves all available services in read-only form.
+Parameters:
+    - None
+Returns:
+    - util::Map<std::string, const Service*> containing all services
+*/
 util::Map<std::string, const Service*> Controller::getServices()
 {
-    return util::Map<std::string, const Service*>();
+    util::Map<std::string, Service*> currentServices = m_serviceManagementService.getServices();
+    util::Map<std::string, const Service*> readOnlyServices;
+    for (int iterator = 0; iterator < currentServices.getSize(); iterator++)
+    {
+        readOnlyServices.insert(currentServices.getValueAt(iterator)->getId(), currentServices.getValueAt(iterator));
+    }
+    return readOnlyServices;
 }
 
+/*
+Function: getComboPackages
+Description: Retrieves all available combo packages from the service
+             management service and constructs a read-only map.
+Parameter: None
+Return type: util::Map<std::string, const ComboPackage*>
+*/
 util::Map<std::string, const ComboPackage*> Controller::getComboPackages()
 {
-    return util::Map<std::string, const ComboPackage*>();
+    util::Map<std::string, ComboPackage*> currentAvailableComboPackages = m_serviceManagementService.getComboPackages();
+    util::Map<std::string, const ComboPackage*> readOnlyComboPackages;
+    for (int iterator = 0; iterator < currentAvailableComboPackages.getSize(); iterator++)
+    {
+        ComboPackage* currentComboPackage = currentAvailableComboPackages.getValueAt(iterator);
+        if (currentComboPackage)
+        {
+            readOnlyComboPackages.insert(currentComboPackage->getId(), currentComboPackage);
+        }
+    }
+    return readOnlyComboPackages;
 }
 
+/*
+Function: purchaseService
+Description: Purchases one or more services for a vehicle by delegating to the service management service.
+Parameter: const util::Vector<std::string>& serviceIDs - IDs of services to purchase
+           const std::string& vehicleNumber - vehicle registration number
+           const std::string& vehicleBrand - brand of the vehicle
+           const std::string& vehicleModel - model of the vehicle
+Return type: void
+*/
 void Controller::purchaseService(const util::Vector<std::string>& serviceIDs, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
 {
+    m_serviceManagementService.purchaseService(serviceIDs, vehicleNumber, vehicleBrand, vehicleModel);
 }
 
+/*
+Function: purchaseComboPackage
+Description: Purchases a combo package for a vehicle by delegating to the service management service.
+Parameter: const std::string& comboPackageID - ID of the combo package
+           const std::string& vehicleNumber - vehicle registration number
+           const std::string& vehicleBrand - brand of the vehicle
+           const std::string& vehicleModel - model of the vehicle
+Return type: void
+*/
 void Controller::purchaseComboPackage(const std::string& comboPackageID, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
 {
+    m_serviceManagementService.purchaseComboPackage(comboPackageID, vehicleNumber, vehicleBrand, vehicleModel);
 }
 
+/*
+Function: getInventoryItems
+Description: Retrieves all inventory items from the inventory management service
+             and constructs a read-only map for external use.
+Parameter: None
+Return type: util::Map<std::string, const InventoryItem*>
+*/
 util::Map<std::string, const InventoryItem*> Controller::getInventoryItems()
 {
-    return util::Map<std::string, const InventoryItem*>();
+    auto inventoryItems = m_inventoryManagementService.getInventoryItems();
+    util::Map<std::string, const InventoryItem*> readOnlyInventoryItems;
+    int inventoryItemsMapSize = inventoryItems.getSize();
+    for (int index = 0; index < inventoryItemsMapSize; index++)
+    {
+        readOnlyInventoryItems.insert(inventoryItems.getKeyAt(index), inventoryItems.getValueAt(index));
+    }
+    return readOnlyInventoryItems;
 }
 
+/*
+Function: getInventoryItem
+Description: Retrieves a specific inventory item by its ID from the inventory management service.
+Parameter: const std::string& inventoryItemID - ID of the inventory item
+Return type: const InventoryItem*
+*/
 const InventoryItem* Controller::getInventoryItem(const std::string& inventoryItemID)
 {
-    return nullptr;
+    return m_inventoryManagementService.getInventoryItem(inventoryItemID);
 }
 
+/*
+Function: addInventoryItem
+Description: Adds a new inventory item with specified details to the inventory management service.
+Parameter: const std::string& partName - name of the part
+           int quantity - quantity of the part
+           double price - price of the part
+Return type: void
+*/
 void Controller::addInventoryItem(const std::string& partName, int quantity, double price)
 {
+    m_inventoryManagementService.addInventoryItem(partName, quantity, price);
 }
 
+/*
+Function: removeInventoryItem
+Description: Removes an inventory item from the inventory management service by its ID.
+Parameter: const std::string& inventoryItemID - ID of the inventory item
+Return type: void
+*/
 void Controller::removeInventoryItem(const std::string& inventoryItemID)
 {
+    m_inventoryManagementService.removeInventoryItem(inventoryItemID);
 }
 
+/*
+Function: addInventoryItemStock
+Description: Adds stock to an existing inventory item in the inventory management service.
+Parameter: const std::string& selectedItemId - ID of the inventory item
+           int quantity - quantity to add
+Return type: void
+*/
+void Controller::addInventoryItemStock(const std::string& selectedItemId, int quantity)
+{
+    m_inventoryManagementService.addInventoryItemStock(selectedItemId, quantity);
+}
+
+/*
+Function: getServiceBookings
+Description: Retrieves all service bookings in read-only form.
+Parameters:
+    - None
+Returns:
+    - util::Map<std::string, const ServiceBooking*> containing service bookings
+*/
 util::Map<std::string, const ServiceBooking*> Controller::getServiceBookings()
 {
-    return util::Map<std::string, const ServiceBooking*>();
+    auto serviceBookings = m_serviceManagementService.getServiceBookings();
+    util::Map<std::string, const ServiceBooking*> readOnlyServiceBookings;
+    for (int iterator = 0; iterator < serviceBookings.getSize(); iterator++)
+    {
+        readOnlyServiceBookings.insert(serviceBookings.getKeyAt(iterator), serviceBookings.getValueAt(iterator));
+    }
+    return readOnlyServiceBookings;
 }
 
+/*
+Function: getServiceBookingsByUser
+Description: Retrieves all service bookings for a specific user.
+Parameters:
+    - userID: std::string, the user ID
+Returns:
+    - util::Map<std::string, const ServiceBooking*> containing bookings for the user
+*/
 util::Map<std::string, const ServiceBooking*> Controller::getServiceBookingsByUser(const std::string userID)
 {
-    return util::Map<std::string, const ServiceBooking*>();
+    util::Map<std::string, const ServiceBooking*> readOnlyServiceBookingsByUserMap;
+    util::Map<std::string, ServiceBooking*> currentServiceBookingsByUser = m_serviceManagementService.getServiceBookings(userID);
+    for (int iterator = 0; iterator < currentServiceBookingsByUser.getSize(); iterator++)
+    {
+        readOnlyServiceBookingsByUserMap.insert(currentServiceBookingsByUser.getValueAt(iterator)->getId(), currentServiceBookingsByUser.getValueAt(iterator));
+    }
+    return readOnlyServiceBookingsByUserMap;
 }
 
+/*
+Function: getUsers
+Description: Retrieves all users from the user management service and
+             constructs a read-only map.
+Parameter: None
+Return type: util::Map<std::string, const User*>
+*/
 util::Map<std::string, const User*> Controller::getUsers()
 {
-    return util::Map<std::string, const User*>();
+    auto listOfUsers = m_userManagementService.getUsers();
+    util::Map<std::string, const User*> readOnlyUserList;
+    for (int iterator = 0; iterator < listOfUsers.getSize(); iterator++)
+    {
+        readOnlyUserList.insert(listOfUsers.getKeyAt(iterator), listOfUsers.getValueAt(iterator));
+    }
+    return readOnlyUserList;
 }
 
+/*
+Function: getUsers
+Description: Retrieves users filtered by user type.
+Parameters:
+    - userType: util::UserType, type of user (CUSTOMER, TECHNICIAN, ADMIN)
+Returns:
+    - util::Map<std::string, const User*> containing users of the specified type
+*/
 util::Map<std::string, const User*> Controller::getUsers(util::UserType userType)
 {
-    return util::Map<std::string, const User*>();
+    auto userMap = m_userManagementService.getUsers(userType);
+    util::Map<std::string, const User*> readOnlyUserMap;
+    for (int iterator = 0; iterator < userMap.getSize(); iterator++)
+    {
+        readOnlyUserMap.insert(userMap.getKeyAt(iterator), userMap.getValueAt(iterator));
+    }
+    return readOnlyUserMap;
 }
 
+/*
+Function: createJobCard
+Description: Creates a job card for a service booking assigned to a technician.
+Parameters:
+    - bookingID: std::string, ID of the service booking
+    - technicianID: std::string, ID of the technician
+    - serviceID: std::string, ID of the service
+Returns:
+    - void
+*/
 void Controller::createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID)
 {
+    m_serviceManagementService.createJobCard(bookingID, technicianID, serviceID);
 }
 
+/*
+Function: createService
+Description: Creates a new service with associated inventory items and labor cost.
+Parameters:
+    - name: std::string, name of the service
+    - inventoryItemIDs: Vector of inventory item IDs
+    - laborCost: double, labor cost
+Returns:
+    - void
+*/
 void Controller::createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost)
 {
+    m_serviceManagementService.createService(name, inventoryItemIDs, laborCost);
 }
 
+/*
+Function: removeService
+Description: Removes a service from the system by ID.
+Parameters:
+    - serviceID: std::string, ID of the service
+Returns:
+    - void
+*/
 void Controller::removeService(const std::string& serviceID)
 {
+    m_serviceManagementService.removeService(serviceID);
 }
 
+/*
+Function: getJobCardsByUser
+Description: Retrieves job cards assigned to the authenticated technician.
+Parameters:
+    - None
+Returns:
+    - util::Map<std::string, const JobCard*> containing job cards
+*/
 util::Map<std::string, const JobCard*> Controller::getJobCardsByUser()
 {
-    return util::Map<std::string, const JobCard*>();
+    const User* currentUser = getAuthenticatedUser();
+    auto jobCardsAssignedToTechnician = m_serviceManagementService.getJobCards(currentUser->getId());
+    util::Map<std::string, const JobCard*> readOnlyJobCardMap;
+    for (int iterator = 0; iterator < jobCardsAssignedToTechnician.getSize(); iterator++)
+    {
+        JobCard* currentJobCard = jobCardsAssignedToTechnician.getValueAt(iterator);
+        readOnlyJobCardMap.insert(currentJobCard->getId(), currentJobCard);
+    }
+    return readOnlyJobCardMap;
 }
 
+/*
+Function: completeJob
+Description: Marks a job card as completed.
+Parameters:
+    - jobID: std::string, ID of the job card
+Returns:
+    - void
+*/
 void Controller::completeJob(const std::string& jobID)
 {
+    m_serviceManagementService.completeJob(jobID);
 }
 
+/*
+Function: removeUser
+Description: Removes a user by ID. Cancels associated service bookings
+             and technician jobs before removing the user from the system.
+Parameter: const std::string& userID - ID of the user to remove
+Return type: void
+*/
 void Controller::removeUser(const std::string& userID)
 {
+    User* user = m_userManagementService.getUser(userID);
+    if (!user)
+    {
+        throw std::runtime_error("Error: User not Found.\n");
+    }
+    m_userManagementService.removeUser(userID);
 }
 
+/*
+Function: createComboPackage
+Description: Creates a new combo package with specified services and discount
+             percentage by delegating to the service management service.
+Parameter: const std::string& name - name of the combo package
+           const util::Vector<std::string>& serviceIDs - list of service IDs
+           double discountPercentage - discount percentage for the package
+Return type: void
+*/
 void Controller::createComboPackage(const std::string& name, const util::Vector<std::string>& serviceIDs, double discountPercentage)
 {
+    m_serviceManagementService.createComboPackage(name, serviceIDs, discountPercentage);
 }
 
+/*
+Function: removeComboPackage
+Description: Removes a combo package by ID by delegating to the service
+             management service.
+Parameter: const std::string& comboPackageID - ID of the combo package
+Return type: void
+*/
 void Controller::removeComboPackage(const std::string& comboPackageID)
 {
+    m_serviceManagementService.removeComboPackage(comboPackageID);
 }
 
+/*
+Function: getInvoicesByUser
+Description: Retrieves all invoices associated with the currently authenticated user.
+             Converts them into a read-only map before returning.
+Parameters:
+    - None
+Returns:
+    - util::Map<std::string, const Invoice*> containing the user’s invoices
+*/
 util::Map<std::string, const Invoice*> Controller::getInvoicesByUser()
 {
-    return util::Map<std::string, const Invoice*>();
+    User* currentUser = m_authenticationManagementService.getAuthenticatedUser();
+    util::Map<std::string, Invoice*> currentUserInvoices =  m_paymentManagementService.getInvoices(currentUser->getId());
+    util::Map<std::string, const Invoice*> userInvoicesReadOnly;
+    for (int iterator = 0; iterator < currentUserInvoices.getSize(); iterator++)
+    {
+        Invoice* currentInvoice = currentUserInvoices.getValueAt(iterator);
+        userInvoicesReadOnly.insert(currentInvoice->getId(), currentInvoice);
+    }
+    return userInvoicesReadOnly;
 }
 
+/*
+Function: completePayment
+Description: Completes payment for a specific invoice using the given payment mode.
+Parameters:
+    - invoiceID: std::string, ID of the invoice to be paid
+    - paymentMode: util::PaymentMode, mode of payment (e.g., ONLINE, OFFLINE)
+Returns:
+    - void
+*/
 void Controller::completePayment(const std::string& invoiceID, util::PaymentMode paymentMode)
 {
+    m_paymentManagementService.completePayment(invoiceID, paymentMode);
 }
 
+/*
+Function: getNotifications
+Description: Retrieves all notifications for the currently authenticated user.
+             Converts them into a read-only vector before returning.
+Parameters: None
+Return type: util::Vector<const Notification*>
+*/
 util::Vector<const Notification*> Controller::getNotifications()
 {
-    return util::Vector<const Notification*>();
+    const User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
+    if (!authenticatedUser)
+    {
+        throw std::runtime_error("No user is currently logged in!");
+    }
+    auto notifications = m_userManagementService.getUserNotifications(authenticatedUser->getId());
+    int numberOfNotifications = notifications.getSize();
+    util::Vector<const Notification*> readOnlyNotifications;
+    for (int index = 0; index < numberOfNotifications; index++)
+    {
+        readOnlyNotifications.push_back(notifications[index]);
+    }
+    return readOnlyNotifications;
 }
 
+/*
+Function: deleteNotification
+Description: Deletes a specific notification for the currently authenticated user.
+Parameters:
+    - notificationID: std::string, the unique identifier of the notification
+Return type: void
+*/
 void Controller::deleteNotification(const std::string& notificationID)
 {
+    const User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
+    if (!authenticatedUser)
+    {
+        throw std::runtime_error("No user is currently logged in!");
+    }
+    m_userManagementService.deleteNotification(notificationID, authenticatedUser->getId());
 }
 
-void Controller::configureNotifications(const std::string& userID, bool paymentNotifications, bool serviceNotifications)
+/*
+Function: configureNotifications
+Description: Configures notification preferences for the authenticated user.
+             Attaches or detaches the user from payment and service notifications.
+Parameters:
+    - paymentNotifications: bool, enable/disable payment notifications
+    - serviceNotifications: bool, enable/disable service notifications
+Return type: void
+*/
+void Controller::configureNotifications(bool paymentNotifications, bool serviceNotifications)
 {
+    User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
+    if (authenticatedUser)
+    {
+        if (paymentNotifications)
+        {
+            m_paymentManagementService.attach(authenticatedUser);
+        }
+        else
+        {
+            m_paymentManagementService.detach(authenticatedUser);
+        }
+        if (serviceNotifications)
+        {
+            m_serviceManagementService.attach(authenticatedUser);
+        }
+        else
+        {
+            m_serviceManagementService.detach(authenticatedUser);
+        }
+    }
+    else
+    {
+        throw std::runtime_error("No user is currently logged in!");
+    }
 }
 
+/*
+Function: loadSystemData
+Description: Loads all system data from persistent storage into memory.
+             Invokes the respective management services to load users, inventory items, services,
+             combo packages, service bookings, job cards, invoices, and observers.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void Controller::loadSystemData()
+{
+    m_userManagementService.loadUsers();
+    m_inventoryManagementService.loadInventoryItems();
+    m_serviceManagementService.loadServices();
+    m_serviceManagementService.loadComboPackages();
+    m_serviceManagementService.loadServiceBookings();
+    m_serviceManagementService.loadJobCards();
+    m_paymentManagementService.loadInvoices();
+    m_serviceManagementService.loadObservers();
+    m_paymentManagementService.loadObservers();
+    m_inventoryManagementService.loadObservers();
+}
+
+/*
+Function: saveSystemData
+Description: Saves all system data from memory back to persistent storage.
+             Invokes the respective management services to save users, inventory items, services,
+             combo packages, service bookings, job cards, invoices, and observers.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void Controller::saveSystemData()
+{
+    m_userManagementService.saveUsers();
+    m_inventoryManagementService.saveInventoryItems();
+    m_serviceManagementService.saveServices();
+    m_serviceManagementService.saveComboPackages();
+    m_serviceManagementService.saveServiceBookings();
+    m_serviceManagementService.saveJobCards();
+    m_paymentManagementService.saveInvoices();
+    m_serviceManagementService.saveObservers();
+    m_paymentManagementService.saveObservers();
+    m_inventoryManagementService.saveObservers();
+}
+
+/*
+Function: runSystemChecks
+Description: Runs system checks to ensure critical configurations, such as verifying admin existence.
+Parameter: None
+Return type: void
+*/
 void Controller::runSystemChecks()
 {
+    m_userManagementService.ensureAdminExists();
+    m_inventoryManagementService.sendLowStockAlerts();
+    m_paymentManagementService.sendPaymentReminders();
 }
 

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

@@ -1,7 +1,21 @@
+/*
+File: Controller.h
+Description: Header file declaring the Controller class, which manages
+             user authentication, inventory, services, bookings, job cards,
+             invoices, and notifications in the system.
+Author: Trenser
+Date:19-May-2026
+*/
+
 #pragma once
-#include "Map.h"
 #include <string>
+#include "AuthenticationManagementService.h"
 #include "Enums.h"
+#include "InventoryManagementService.h"
+#include "Map.h"
+#include "PaymentManagementService.h"
+#include "ServiceManagementService.h"
+#include "UserManagementService.h"
 
 class Service;
 class ComboPackage;
@@ -14,13 +28,19 @@ class Notification;
 
 class Controller
 {
+private:
+    AuthenticationManagementService  m_authenticationManagementService;
+    UserManagementService m_userManagementService;
+    ServiceManagementService m_serviceManagementService;    
+    InventoryManagementService m_inventoryManagementService;
+    PaymentManagementService m_paymentManagementService;
 public:
     bool login(const std::string& username, const std::string& password);
     void logout();
     void changePassword(const std::string& newPassword);
-    void createCustomer(const std::string& username, const std::string& password, const std::string& email, const std::string& phone);
+    void createCustomer(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone);
     const User* getAuthenticatedUser();
-    void createTechnician(const std::string& username, const std::string& password, const std::string& email, const std::string& phone);
+    void createTechnician(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone);
     void updateUserDetails(const std::string& email, const std::string& phone);
     util::Map<std::string, const Service*> getServices();
     util::Map<std::string, const ComboPackage*> getComboPackages();
@@ -29,6 +49,7 @@ public:
     util::Map<std::string, const InventoryItem*> getInventoryItems();
     const InventoryItem* getInventoryItem(const std::string& inventoryItemID);
     void addInventoryItem(const std::string& partName, int quantity, double price);
+    void addInventoryItemStock(const std::string& selectedItemId, int quantity);
     void removeInventoryItem(const std::string& inventoryItemID);
     util::Map<std::string, const ServiceBooking*> getServiceBookings();
     util::Map<std::string, const ServiceBooking*> getServiceBookingsByUser(const std::string userID);
@@ -46,6 +67,8 @@ public:
     void completePayment(const std::string& invoiceID, util::PaymentMode paymentMode);
     util::Vector<const Notification*> getNotifications();
     void deleteNotification(const std::string& notificationID);
-    void configureNotifications(const std::string& userID, bool paymentNotifications, bool serviceNotifications);
+    void configureNotifications(bool paymentNotifications, bool serviceNotifications);
+    void loadSystemData();
+    void saveSystemData();
     void runSystemChecks();
 };

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

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

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

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

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

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

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

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

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

@@ -1,65 +1,341 @@
+/*
+File: ComboPackage.cpp
+Description: Implements the ComboPackage class which represents a bundled set of services in the Vehicle Service Management System.
+             Provides constructors, accessors, and mutators for package details such as ID, name, discount percentage, state,
+             and associated services.
+Author: Trenser
+Date: 19-May-2026
+*/
+
+#include <sstream>
+#include <stdexcept>
 #include "ComboPackage.h"
+#include "Service.h"
+#include "Factory.h"
+#include "StringHelper.h"
 
 int ComboPackage::m_uid = 0;
 
+/*
+Function: ComboPackage
+Description: Default constructor that initializes a new combo package with a unique ID,
+             active state, and zero discount percentage.
+Parameters:
+    - None
+Returns:
+    - A new ComboPackage object.
+*/
 ComboPackage::ComboPackage()
     : m_id("CMP" + std::to_string(++m_uid)),
     m_status(util::State::ACTIVE),
     m_discountPercentage(0.0) {}
 
+/*
+Function: ComboPackage
+Description: Parameterized constructor that initializes a new combo package with a unique ID,
+             specified package name, discount percentage, active state, and associated services.
+Parameters:
+    - packageName: Name of the combo package.
+    - discountPercentage: Discount percentage applied to the package.
+    - services: Map of services included in the package.
+Returns:
+    - A new ComboPackage object.
+*/
 ComboPackage::ComboPackage(const std::string& packageName, double discountPercentage, const util::Map<std::string, Service*>& services)
     : m_id("CMP" + std::to_string(++m_uid)),
     m_packageName(packageName),
     m_discountPercentage(discountPercentage),
     m_status(util::State::ACTIVE),
-    m_services(services) {}
+    m_services(services)
+{
+    int numberOfServices = m_services.getSize();
+    auto servicePointers = m_services.getValues();
+    for (int index = 0; index < numberOfServices; index++)
+    {
+        m_serviceIDs.push_back(servicePointers[index]->getId());
+    }
+}
 
+/*
+Function: ComboPackage (parameterized constructor with ID)
+Description: Initializes a combo package with an existing ID, name, discount percentage,
+             service IDs, and state. Updates UID tracking based on ID.
+Parameters:
+    - id: const std::string&, unique ID of the package
+    - packageName: const std::string&, name of the package
+    - discountPercentage: double, discount percentage applied
+    - serviceIDs: const util::Vector<std::string>&, IDs of services included
+    - status: util::State, state of the package (ACTIVE/INACTIVE)
+Returns:
+    - A new ComboPackage object
+*/
+ComboPackage::ComboPackage(const std::string& id, const std::string& packageName, double discountPercentage, const util::Vector<std::string>& serviceIDs, util::State status)
+    : m_id(id),
+    m_packageName(packageName),
+    m_discountPercentage(discountPercentage),
+    m_serviceIDs(serviceIDs),
+    m_status(status)
+{
+    int idNumber = util::extractNumber(m_id);
+    if (idNumber > m_uid)
+    {
+        m_uid = idNumber;
+    }
+}
+
+/*
+Function: getId
+Description: Retrieves the unique ID of the combo package.
+Parameters:
+    - None
+Returns:
+    - const std::string& representing the package ID.
+*/
 const std::string& ComboPackage::getId() const
 {
     return m_id;
 }
 
+/*
+Function: getPackageName
+Description: Retrieves the name of the combo package.
+Parameters:
+    - None
+Returns:
+    - const std::string& representing the package name.
+*/
 const std::string& ComboPackage::getPackageName() const
 {
     return m_packageName;
 }
 
+/*
+Function: getDiscountPercentage
+Description: Retrieves the discount percentage applied to the combo package.
+Parameters:
+    - None
+Returns:
+    - double representing the discount percentage.
+*/
 double ComboPackage::getDiscountPercentage() const
 {
     return m_discountPercentage;
 }
 
+/*
+Function: getState
+Description: Retrieves the current state (ACTIVE/INACTIVE) of the combo package.
+Parameters:
+    - None
+Returns:
+    - util::State representing the package state.
+*/
 util::State ComboPackage::getState() const
 {
     return m_status;
 }
 
+const util::Vector<std::string>& ComboPackage::getServiceIDs() const
+{
+    return m_serviceIDs;
+}
+
+/*
+Function: getServices
+Description: Retrieves the map of services included in the combo package.
+Parameters:
+    - None
+Returns:
+    - const util::Map<std::string, Service*>& representing the services.
+*/
 const util::Map<std::string, Service*>& ComboPackage::getServices() const
 {
     return m_services;
 }
 
+/*
+Function: setId
+Description: Sets the unique ID of the combo package.
+Parameters:
+    - id: New ID string.
+Returns:
+    - void
+*/
 void ComboPackage::setId(const std::string& id)
 {
     m_id = id;
 }
 
+/*
+Function: setPackageName
+Description: Sets the name of the combo package.
+Parameters:
+    - packageName: New package name string.
+Returns:
+    - void
+*/
 void ComboPackage::setPackageName(const std::string& packageName)
 {
     m_packageName = packageName;
 }
 
+/*
+Function: setDiscountPercentage
+Description: Sets the discount percentage for the combo package.
+Parameters:
+    - discountPercentage: New discount percentage value.
+Returns:
+    - void
+*/
 void ComboPackage::setDiscountPercentage(double discountPercentage)
 {
     m_discountPercentage = discountPercentage;
 }
 
+/*
+Function: setServices
+Description: Sets the services included in the combo package.
+Parameters:
+    - services: Map of services to be associated with the package.
+Returns:
+    - void
+*/
 void ComboPackage::setServices(const util::Map<std::string, Service*>& services)
 {
     m_services = services;
+    m_serviceIDs.clear();
+    int numberOfServices = m_services.getSize();
+    auto servicePointers = m_services.getValues();
+    for (int index = 0; index < numberOfServices; index++)
+    {
+        m_serviceIDs.push_back(servicePointers[index]->getId());
+    }
 }
 
+/*
+Function: setState
+Description: Sets the state (ACTIVE/INACTIVE) of the combo package.
+Parameters:
+    - status: New state value.
+Returns:
+    - void
+*/
 void ComboPackage::setState(util::State status)
 {
     m_status = status;
 }
+
+/*
+Function: getServiceIDsAsString (static helper)
+Description: Converts a vector of service IDs into a single string separated by '|'.
+Parameters:
+    - serviceIDs: const util::Vector<std::string>&, vector of service IDs
+Returns:
+    - std::string: Concatenated service IDs string
+*/
+static std::string getServiceIDsAsString(const util::Vector<std::string>& serviceIDs)
+{
+    int numberOfServices = serviceIDs.getSize();
+    std::string serviceIDsString;
+    for (int index = 0; index < numberOfServices; index++)
+    {
+        serviceIDsString += serviceIDs[index];
+        if (index < numberOfServices - 1)
+        {
+            serviceIDsString += '|';
+        }
+    }
+    return serviceIDsString;
+}
+
+/*
+Function: getServiceIDsAsVector (static helper)
+Description: Converts a string of service IDs separated by '|' into a vector.
+Parameters:
+    - serviceIDsString: const std::string&, concatenated service IDs string
+Returns:
+    - util::Vector<std::string>: Vector of service IDs
+*/
+static util::Vector<std::string> getServiceIDsAsVector(const std::string& serviceIDsString)
+{
+    util::Vector<std::string> serviceIDs;
+    std::string serviceID;
+    std::istringstream serializedServiceIDs(serviceIDsString);
+    while (getline(serializedServiceIDs, serviceID, '|'))
+    {
+        serviceIDs.push_back(serviceID);
+    }
+    return serviceIDs;
+}
+
+/*
+Function: serialize
+Description: Serializes the combo package into a CSV-formatted string.
+Parameters:
+    - None
+Returns:
+    - std::string: Serialized combo package record
+*/
+std::string ComboPackage::serialize() const
+{
+    std::ostringstream serializedComboPackage;
+    serializedComboPackage << m_id << ','
+        << m_packageName << ','
+        << m_discountPercentage << ','
+        << getServiceIDsAsString(m_serviceIDs) << ','
+        << util::getStateString(m_status);
+    return serializedComboPackage.str();
+}
+
+/*
+Function: deserialize
+Description: Deserializes a CSV-formatted string into a ComboPackage object.
+Parameters:
+    - record: const std::string&, serialized combo package record
+Returns:
+    - ComboPackage*: Pointer to the deserialized ComboPackage object
+Throws:
+    - std::runtime_error if data is invalid
+*/
+ComboPackage* ComboPackage::deserialize(const std::string& record)
+{
+    std::string id, packageName;
+    std::string discountPercentageString, serviceIDsString, statusString;
+    double discountPercentage;
+    std::istringstream serializedComboPackage(record);
+    getline(serializedComboPackage, id, ',');
+    getline(serializedComboPackage, packageName, ',');
+    getline(serializedComboPackage, discountPercentageString, ',');
+    getline(serializedComboPackage, serviceIDsString, ',');
+    getline(serializedComboPackage, statusString, ',');
+    try
+    {
+        discountPercentage = std::stod(discountPercentageString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid combo package data");
+    }
+    util::Vector<std::string> serviceIDs = getServiceIDsAsVector(serviceIDsString);
+    util::State status = util::getState(statusString);
+    return Factory::getObject<ComboPackage>(
+        id,
+        packageName,
+        discountPercentage,
+        serviceIDs,
+        status
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for combo package serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,PackageName,DiscountPercentage,ServiceIDs,Status")
+*/
+std::string ComboPackage::getHeaders()
+{
+    return "ID,PackageName,DiscountPercentage,ServiceIDs,Status";
+}

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

@@ -1,6 +1,14 @@
+/*
+File: ComboPackage.h
+Description: Declares the ComboPackage class which represents a service package with a unique ID, package name, discount percentage, associated services, and status in the Vehicle Service Management System.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #pragma once
 #include <string>
 #include "Map.h"
+#include "Vector.h"
 #include "Enums.h"
 
 class Service;
@@ -12,14 +20,17 @@ private:
     std::string m_id;
     std::string m_packageName;
     double m_discountPercentage;
+    util::Vector<std::string> m_serviceIDs;
     util::Map<std::string, Service*> m_services;
     util::State m_status;
 public:
     ComboPackage();
     ComboPackage(const std::string& packageName, double discountPercentage, const util::Map<std::string, Service*>& services);
+    ComboPackage(const std::string& id, const std::string& packageName, double discountPercentage, const util::Vector<std::string>& serviceIDs, util::State status);
     const std::string& getId() const;
     const std::string& getPackageName() const;
     double getDiscountPercentage() const;
+    const util::Vector<std::string>& getServiceIDs() const;
     const util::Map<std::string, Service*>& getServices() const;
     util::State getState() const;
     void setId(const std::string& id);
@@ -27,4 +38,7 @@ public:
     void setDiscountPercentage(double discountPercentage);
     void setServices(const util::Map<std::string, Service*>& services);
     void setState(util::State status);
+    std::string serialize() const;
+    static ComboPackage* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

@@ -1,13 +1,45 @@
+/*
+File: InventoryItem.cpp
+Description: Implements the InventoryItem class which represents an inventory item in the Vehicle Service Management System.
+             Provides constructors, accessors, and mutators for item details such as ID, part name, quantity, price, and state.
+Author: Trenser
+Date: 19-May-2026
+*/
+
+#include <sstream>
+#include <stdexcept>
+#include "Factory.h"
+#include "StringHelper.h"
 #include "InventoryItem.h"
 
 int InventoryItem::m_uid = 0;
 
+/*
+Function: InventoryItem
+Description: Default constructor that initializes a new inventory item with a unique ID,
+             active state, zero quantity, and zero price.
+Parameters:
+    - None
+Returns:
+    - A new InventoryItem object.
+*/
 InventoryItem::InventoryItem()
     : m_id("IIM" + std::to_string(++m_uid)),
     m_quantity(0),
     m_status(util::State::ACTIVE),
     m_price(0.0) {}
 
+/*
+Function: InventoryItem
+Description: Parameterized constructor that initializes a new inventory item with a unique ID,
+             specified part name, quantity, price, and active state.
+Parameters:
+    - partName: Name of the inventory item.
+    - quantity: Initial quantity of the item.
+    - price: Price of the item.
+Returns:
+    - A new InventoryItem object.
+*/
 InventoryItem::InventoryItem(const std::string& partName, int quantity, double price)
     : m_id("IIM" + std::to_string(++m_uid)),
     m_partName(partName),
@@ -15,52 +47,232 @@ InventoryItem::InventoryItem(const std::string& partName, int quantity, double p
     m_status(util::State::ACTIVE),
     m_price(price) {}
 
+/*
+Function: InventoryItem (parameterized constructor with ID)
+Description: Initializes an inventory item with an existing ID, part name, quantity,
+             price, and state. Updates UID tracking based on ID.
+Parameters:
+    - id: const std::string&, unique ID of the item
+    - partName: const std::string&, name of the part
+    - quantity: int, quantity of the part
+    - price: double, price of the part
+    - status: util::State, state of the item (ACTIVE/INACTIVE)
+Returns:
+    - A new InventoryItem object
+*/
+InventoryItem::InventoryItem(const std::string& id, const std::string& partName, int quantity, double price, util::State status)
+    : m_id(id),
+    m_partName(partName),
+    m_quantity(quantity),
+    m_status(status),
+    m_price(price)
+{
+    int idNumber = util::extractNumber(m_id);
+    if (idNumber > m_uid)
+    {
+        m_uid = idNumber;
+    }
+}
+
+/*
+Function: getId
+Description: Retrieves the unique ID of the inventory item.
+Parameters:
+    - None
+Returns:
+    - const std::string& representing the item ID.
+*/
 const std::string& InventoryItem::getId() const
 {
     return m_id;
 }
 
+/*
+Function: getPartName
+Description: Retrieves the part name of the inventory item.
+Parameters:
+    - None
+Returns:
+    - const std::string& representing the part name.
+*/
 const std::string& InventoryItem::getPartName() const
 {
     return m_partName;
 }
 
+/*
+Function: getQuantity
+Description: Retrieves the current quantity of the inventory item.
+Parameters:
+    - None
+Returns:
+    - int representing the quantity.
+*/
 int InventoryItem::getQuantity() const
 {
     return m_quantity;
 }
 
+/*
+Function: getPrice
+Description: Retrieves the price of the inventory item.
+Parameters:
+    - None
+Returns:
+    - double representing the price.
+*/
 double InventoryItem::getPrice() const
 {
     return m_price;
 }
 
+/*
+Function: getState
+Description: Retrieves the current state (ACTIVE/INACTIVE) of the inventory item.
+Parameters:
+    - None
+Returns:
+    - util::State representing the item state.
+*/
 util::State InventoryItem::getState() const
 {
     return m_status;
 }
 
+/*
+Function: setId
+Description: Sets the unique ID of the inventory item.
+Parameters:
+    - id: New ID string.
+Returns:
+    - void
+*/
 void InventoryItem::setId(const std::string& id)
 {
     m_id = id;
 }
 
+/*
+Function: setPartName
+Description: Sets the part name of the inventory item.
+Parameters:
+    - partName: New part name string.
+Returns:
+    - void
+*/
 void InventoryItem::setPartName(const std::string& partName)
 {
     m_partName = partName;
 }
 
+/*
+Function: setQuantity
+Description: Sets the quantity of the inventory item.
+Parameters:
+    - quantity: New quantity value.
+Returns:
+    - void
+*/
 void InventoryItem::setQuantity(int quantity)
 {
     m_quantity = quantity;
 }
 
+/*
+Function: setPrice
+Description: Sets the price of the inventory item.
+Parameters:
+    - price: New price value.
+Returns:
+    - void
+*/
 void InventoryItem::setPrice(double price)
 {
     m_price = price;
 }
 
+/*
+Function: setState
+Description: Sets the state (ACTIVE/INACTIVE) of the inventory item.
+Parameters:
+    - status: New state value.
+Returns:
+    - void
+*/
 void InventoryItem::setState(util::State status)
 {
     m_status = status;
+}
+
+/*
+Function: serialize
+Description: Serializes the inventory item into a CSV-formatted string.
+Parameters:
+    - None
+Returns:
+    - std::string: Serialized inventory item record
+*/
+std::string InventoryItem::serialize() const
+{
+    std::ostringstream serializedInventoryItem;
+    serializedInventoryItem << m_id << ','
+        << m_partName << ','
+        << m_quantity << ','
+        << m_price << ','
+        << util::getStateString(m_status);
+    return serializedInventoryItem.str();
+}
+
+/*
+Function: deserialize
+Description: Deserializes a CSV-formatted string into an InventoryItem object.
+Parameters:
+    - record: const std::string&, serialized inventory item record
+Returns:
+    - InventoryItem*: Pointer to the deserialized InventoryItem object
+Throws:
+    - std::runtime_error if data is invalid
+*/
+InventoryItem* InventoryItem::deserialize(const std::string& record)
+{
+    std::string id, partName;
+    std::string quantityString, priceString, statusString;
+    int quantity;
+    double price;
+    std::istringstream serializedInventoryItem(record);
+    getline(serializedInventoryItem, id, ',');
+    getline(serializedInventoryItem, partName, ',');
+    getline(serializedInventoryItem, quantityString, ',');
+    getline(serializedInventoryItem, priceString, ',');
+    getline(serializedInventoryItem, statusString, ',');
+    try
+    {
+        quantity = std::stoi(quantityString);
+        price = std::stod(priceString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid inventory item data");
+    }
+    util::State status = util::getState(statusString);
+    return Factory::getObject<InventoryItem>(
+        id,
+        partName,
+        quantity,
+        price,
+        status
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for inventory item serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,PartName,Quantity,Price,Status")
+*/
+std::string InventoryItem::getHeaders()
+{
+    return "ID,PartName,Quantity,Price,Status";
 }

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

@@ -1,3 +1,12 @@
+/*
+File: InventoryItem.h
+Description: Declares the InventoryItem class which represents parts in the Vehicle Service Management System.
+             Each item has a unique ID, part name, quantity, price, and status.
+Author: Trenser
+Date: 19-May-2026
+*/
+
+
 #pragma once
 #include <string>
 #include "Enums.h"
@@ -14,6 +23,7 @@ private:
 public:
     InventoryItem();
     InventoryItem(const std::string& partName, int quantity, double price);
+    InventoryItem(const std::string& id, const std::string& partName, int quantity, double price, util::State status);
     const std::string& getId() const;
     const std::string& getPartName() const;
     int getQuantity() const;
@@ -24,4 +34,7 @@ public:
     void setQuantity(int quantity);
     void setPrice(double price);
     void setState(util::State status);
+    std::string serialize() const;
+    static InventoryItem* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

@@ -1,7 +1,31 @@
+/*
+File: Invoice.cpp
+Description: Implements the Invoice class which represents an invoice in the Vehicle Service Management System.
+             Provides constructors, accessors, and mutators for invoice details such as ID, booking, costs,
+             discount percentage, total amount, payment details, and status.
+Author: Trenser
+Date: 19-May-2026
+*/
+
+#include <sstream>
+#include <stdexcept>
 #include "Invoice.h"
+#include "Factory.h"
+#include "InventoryItem.h"
+#include "StringHelper.h"
 
 int Invoice::m_uid = 0;
 
+/*
+Function: Invoice
+Description: Default constructor that initializes a new invoice with a unique ID,
+             null booking, zero costs, zero discount, zero total amount,
+             and default payment method and status.
+Parameters:
+    - None
+Returns:
+    - A new Invoice object.
+*/
 Invoice::Invoice()
     : m_id("INV" + std::to_string(++m_uid)),
     m_booking(nullptr),
@@ -12,12 +36,30 @@ Invoice::Invoice()
     m_paymentMethod(util::PaymentMode()),
     m_status(util::PaymentStatus()) {}
 
+/*
+Function: Invoice
+Description: Parameterized constructor that initializes a new invoice with a unique ID and specified details.
+Parameters:
+    - bookingId: ID of the associated service booking.
+    - booking: Pointer to the ServiceBooking object.
+    - invoiceDate: Timestamp of when the invoice was created.
+    - laborCost: Cost of labor for the service.
+    - parts: Map of inventory items used in the service.
+    - partsCost: Total cost of parts.
+    - discountPercentage: Discount applied to the invoice.
+    - totalAmount: Final total amount after discount.
+    - paymentDate: Timestamp of when payment was made.
+    - paymentMethod: Payment mode (ONLINE/OFFLINE).
+    - status: Payment status (PENDING/COMPLETED).
+Returns:
+    - A new Invoice object.
+*/
 Invoice::Invoice(
     const std::string& bookingId,
     ServiceBooking* booking,
     const util::Timestamp& invoiceDate, 
-    double laborCost, const util::Map<int,
+    double laborCost, 
-    InventoryItem*>& parts,
+    const util::Map<std::string, InventoryItem*>& parts,
     double partsCost,
     double discountPercentage, 
     double totalAmount, 
@@ -36,124 +78,495 @@ Invoice::Invoice(
     m_totalAmount(totalAmount),
     m_paymentDate(paymentDate),
     m_paymentMethod(paymentMethod),
-    m_status(status) {}
+    m_status(status) 
+{
+    int numberOfParts = m_parts.getSize();
+    auto partPointers = m_parts.getValues();
+    for (int index = 0; index < numberOfParts; index++)
+    {
+        m_partIDs.push_back(partPointers[index]->getId());
+    }
+}
+Invoice::Invoice(
+    const std::string& id,
+    const std::string& bookingId,
+    const util::Timestamp& invoiceDate,
+    const util::Vector<std::string>& partIDs,
+    double laborCost,
+    double partsCost,
+    double discountPercentage,
+    double totalAmount,
+    const util::Timestamp& paymentDate,
+    util::PaymentMode paymentMethod,
+    util::PaymentStatus status
+)
+    : m_id(id),
+    m_bookingId(bookingId),
+    m_booking(nullptr),
+    m_invoiceDate(invoiceDate),
+    m_partIDs(partIDs),
+    m_laborCost(laborCost),
+    m_partsCost(partsCost),
+    m_discountPercentage(discountPercentage),
+    m_totalAmount(totalAmount),
+    m_paymentDate(paymentDate),
+    m_paymentMethod(paymentMethod),
+    m_status(status)
+{
+    int idNumber = util::extractNumber(m_id);
+    if (idNumber > m_uid)
+    {
+        m_uid = idNumber;
+    }
+}
 
+/*
+Function: getId
+Description: Retrieves the unique ID of the invoice.
+Returns:
+    - const std::string& representing the invoice ID.
+*/
 const std::string& Invoice::getId() const
 {
     return m_id;
 }
 
+/*
+Function: getBookingId
+Description: Retrieves the booking ID associated with the invoice.
+Returns:
+    - const std::string& representing the booking ID.
+*/
 const std::string& Invoice::getBookingId() const
 {
     return m_bookingId;
 }
 
+/*
+Function: getBooking
+Description: Retrieves the pointer to the associated ServiceBooking.
+Returns:
+    - ServiceBooking* representing the booking.
+*/
 ServiceBooking* Invoice::getBooking() const
 {
     return m_booking;
 }
 
+/*
+Function: getInvoiceDate
+Description: Retrieves the timestamp of the invoice creation date.
+Returns:
+    - const util::Timestamp& representing the invoice date.
+*/
 const util::Timestamp& Invoice::getInvoiceDate() const
 {
     return m_invoiceDate;
 }
 
+/*
+Function: getLaborCost
+Description: Retrieves the labor cost associated with the invoice.
+Returns:
+    - double representing the labor cost.
+*/
 double Invoice::getLaborCost() const
 {
     return m_laborCost;
 }
 
-const util::Map<int, InventoryItem*>& Invoice::getParts() const
+/*
+Function: getPartIDs
+Description: Retrieves the IDs of parts used in the invoice.
+Parameters:
+    - None
+Returns:
+    - const util::Vector<std::string>&: Part IDs
+*/
+const util::Vector<std::string>& Invoice::getPartIDs() const
+{
+    return m_partIDs;
+}
+
+/*
+Function: getParts
+Description: Retrieves the map of inventory items used in the service.
+Returns:
+    - const util::Map<int, InventoryItem*>& representing the parts.
+*/
+const util::Map<std::string, InventoryItem*>& Invoice::getParts() const
 {
     return m_parts;
 }
 
+/*
+Function: getPartsCost
+Description: Retrieves the total cost of parts used in the service.
+Returns:
+    - double representing the parts cost.
+*/
 double Invoice::getPartsCost() const
 {
     return m_partsCost;
 }
 
+/*
+Function: getDiscountPercentage
+Description: Retrieves the discount percentage applied to the invoice.
+Returns:
+    - double representing the discount percentage.
+*/
 double Invoice::getDiscountPercentage() const
 {
     return m_discountPercentage;
 }
 
+/*
+Function: getTotalAmount
+Description: Retrieves the total amount of the invoice after discount.
+Returns:
+    - double representing the total amount.
+*/
 double Invoice::getTotalAmount() const
 {
     return m_totalAmount;
 }
 
+/*
+Function: getPaymentDate
+Description: Retrieves the timestamp of the payment date.
+Returns:
+    - const util::Timestamp& representing the payment date.
+*/
 const util::Timestamp& Invoice::getPaymentDate() const
 {
     return m_paymentDate;
 }
 
+/*
+Function: getPaymentMethod
+Description: Retrieves the payment mode used for the invoice.
+Returns:
+    - util::PaymentMode representing the payment method.
+*/
 util::PaymentMode Invoice::getPaymentMethod() const
 {
     return m_paymentMethod;
 }
 
+/*
+Function: getStatus
+Description: Retrieves the payment status of the invoice.
+Returns:
+    - util::PaymentStatus representing the payment status.
+*/
 util::PaymentStatus Invoice::getStatus() const
 {
     return m_status;
 }
 
+/*
+Function: setId
+Description: Sets the unique ID of the invoice.
+Parameters:
+    - id: New invoice ID string.
+Returns:
+    - void
+*/
 void Invoice::setId(const std::string& id)
 {
     m_id = id;
 }
 
+/*
+Function: setBookingId
+Description: Sets the booking ID associated with the invoice.
+Parameters:
+    - bookingId: New booking ID string.
+Returns:
+    - void
+*/
 void Invoice::setBookingId(const std::string& bookingId)
 {
     m_bookingId = bookingId;
 }
 
+/*
+Function: setBooking
+Description: Sets the associated ServiceBooking pointer.
+Parameters:
+    - booking: Pointer to the ServiceBooking object.
+Returns:
+    - void
+*/
 void Invoice::setBooking(ServiceBooking* booking)
 {
     m_booking = booking;
 }
 
+/*
+Function: setInvoiceDate
+Description: Sets the invoice creation date.
+Parameters:
+    - invoiceDate: New timestamp for the invoice date.
+Returns:
+    - void
+*/
 void Invoice::setInvoiceDate(const util::Timestamp& invoiceDate)
 {
     m_invoiceDate = invoiceDate;
 }
 
+/*
+Function: setLaborCost
+Description: Sets the labor cost for the invoice.
+Parameters:
+    - laborCost: New labor cost value.
+Returns:
+    - void
+*/
 void Invoice::setLaborCost(double laborCost)
 {
     m_laborCost = laborCost;
 }
 
-void Invoice::setParts(const util::Map<int, InventoryItem*>& parts)
+/*
+Function: setParts
+Description: Sets the inventory items used in the service.
+Parameters:
+    - parts: Map of inventory items.
+Returns:
+    - void
+*/
+void Invoice::setParts(const util::Map<std::string, InventoryItem*>& parts)
 {
     m_parts = parts;
+    m_partIDs.clear();
+    int numberOfParts = m_parts.getSize();
+    auto partPointers = m_parts.getValues();
+    for (int index = 0; index < numberOfParts; index++)
+    {
+        m_partIDs.push_back(partPointers[index]->getId());
+    }
 }
 
+/*
+Function: setPartsCost
+Description: Sets the total cost of parts used in the service.
+Parameters:
+    - partsCost: New parts cost value.
+Returns:
+    - void
+*/
 void Invoice::setPartsCost(double partsCost)
 {
     m_partsCost = partsCost;
 }
 
+/*
+Function: setDiscountPercentage
+Description: Sets the discount percentage applied to the invoice.
+Parameters:
+    - discountPercentage: New discount percentage value.
+Returns:
+    - void
+*/
 void Invoice::setDiscountPercentage(double discountPercentage)
 {
     m_discountPercentage = discountPercentage;
 }
 
+/*
+Function: setTotalAmount
+Description: Sets the total amount of the invoice.
+Parameters:
+    - totalAmount: New total amount value.
+Returns:
+    - void
+*/
 void Invoice::setTotalAmount(double totalAmount)
 {
     m_totalAmount = totalAmount;
 }
 
+/*
+Function: setPaymentDate
+Description: Sets the payment date for the invoice.
+Parameters:
+    - paymentDate: New timestamp for the payment date.
+Returns:
+    - void
+*/
 void Invoice::setPaymentDate(const util::Timestamp& paymentDate)
 {
     m_paymentDate = paymentDate;
 }
 
+/*
+Function: setPaymentMethod
+Description: Sets the payment mode for the invoice.
+Parameters:
+    - paymentMethod: New payment mode value.
+Returns:
+    - void
+*/
 void Invoice::setPaymentMethod(util::PaymentMode paymentMethod)
 {
     m_paymentMethod = paymentMethod;
 }
 
+/*
+Function: setStatus
+Description: Sets the payment status of the invoice.
+Parameters:
+    - status: New payment status value.
+Returns:
+    - void
+*/
 void Invoice::setStatus(util::PaymentStatus status)
 {
     m_status = status;
 }
+
+/*
+Function: getPartIDsAsString (static helper)
+Description: Converts a vector of part IDs into a single string separated by '|'.
+Parameters:
+    - partIDs: const util::Vector<std::string>&, vector of part IDs
+Returns:
+    - std::string: Concatenated part IDs string
+*/
+static std::string getPartIDsAsString(const util::Vector<std::string>& partIDs)
+{
+    int numberOfParts = partIDs.getSize();
+    std::string partIDsString;
+    for (int index = 0; index < numberOfParts; index++)
+    {
+        partIDsString += partIDs[index];
+        if (index < numberOfParts - 1)
+        {
+            partIDsString += '|';
+        }
+    }
+    return partIDsString;
+}
+
+/*
+Function: getPartIDsAsVector (static helper)
+Description: Converts a string of part IDs separated by '|' into a vector.
+Parameters:
+    - partIDsString: const std::string&, concatenated part IDs string
+Returns:
+    - util::Vector<std::string>: Vector of part IDs
+*/
+static util::Vector<std::string> getPartIDsAsVector(const std::string& partIDsString)
+{
+    util::Vector<std::string> partIDs;
+    std::string partID;
+    std::istringstream serializedPartIDs(partIDsString);
+    while (getline(serializedPartIDs, partID, '|'))
+    {
+        partIDs.push_back(partID);
+    }
+    return partIDs;
+}
+
+/*
+Function: serialize
+Description: Serializes the invoice into a CSV-formatted string.
+Parameters:
+    - None
+Returns:
+    - std::string: Serialized invoice record
+*/
+std::string Invoice::serialize() const
+{
+    std::ostringstream serializedInvoice;
+    serializedInvoice << m_id << ','
+        << m_bookingId << ','
+        << m_invoiceDate.toString() << ','
+        << m_laborCost << ','
+        << getPartIDsAsString(m_partIDs) << ','
+        << m_partsCost << ','
+        << m_discountPercentage << ','
+        << m_totalAmount << ','
+        << m_paymentDate.toString() << ','
+        << util::getPaymentModeString(m_paymentMethod) << ','
+        << util::getPaymentStatusString(m_status);
+    return serializedInvoice.str();
+}
+
+/*
+Function: deserialize
+Description: Deserializes a CSV-formatted string into an Invoice object.
+Parameters:
+    - record: const std::string&, serialized invoice record
+Returns:
+    - Invoice*: Pointer to the deserialized Invoice object
+Throws:
+    - std::runtime_error if data is invalid
+*/
+Invoice* Invoice::deserialize(const std::string& record)
+{
+    std::string id, bookingId;
+    std::string invoiceDateString, laborCostString, partIDsString;
+    std::string partsCostString, discountPercentageString, totalAmountString;
+    std::string paymentDateString, paymentMethodString, statusString;
+    double laborCost, partsCost, discountPercentage, totalAmount;
+    std::istringstream serializedInvoice(record);
+    getline(serializedInvoice, id, ',');
+    getline(serializedInvoice, bookingId, ',');
+    getline(serializedInvoice, invoiceDateString, ',');
+    getline(serializedInvoice, laborCostString, ',');
+    getline(serializedInvoice, partIDsString, ',');
+    getline(serializedInvoice, partsCostString, ',');
+    getline(serializedInvoice, discountPercentageString, ',');
+    getline(serializedInvoice, totalAmountString, ',');
+    getline(serializedInvoice, paymentDateString, ',');
+    getline(serializedInvoice, paymentMethodString, ',');
+    getline(serializedInvoice, statusString, ',');
+    util::Timestamp invoiceDate;
+    util::Timestamp paymentDate;
+    try
+    {
+        invoiceDate = util::Timestamp::fromString(invoiceDateString);
+        paymentDate = util::Timestamp::fromString(paymentDateString);
+        laborCost = std::stod(laborCostString);
+        partsCost = std::stod(partsCostString);
+        discountPercentage = std::stod(discountPercentageString);
+        totalAmount = std::stod(totalAmountString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid invoice data");
+    }
+    util::Vector<std::string> partIDs = getPartIDsAsVector(partIDsString);
+    util::PaymentMode paymentMethod = util::getPaymentMode(paymentMethodString);
+    util::PaymentStatus status = util::getPaymentStatus(statusString);
+    return Factory::getObject<Invoice>(
+        id,
+        bookingId,
+        invoiceDate,
+        partIDs,
+        laborCost,
+        partsCost,
+        discountPercentage,
+        totalAmount,
+        paymentDate,
+        paymentMethod,
+        status
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for invoice serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,BookingID,InvoiceDate,LaborCost,PartIDs,PartsCost,DiscountPercentage,TotalAmount,PaymentDate,PaymentMethod,Status")
+*/
+std::string Invoice::getHeaders()
+{
+    return "ID,BookingID,InvoiceDate,LaborCost,PartIDs,PartsCost,DiscountPercentage,TotalAmount,PaymentDate,PaymentMethod,Status";
+}

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

@@ -1,6 +1,16 @@
+/*
+File: Invoice.h
+Description: Declares the Invoice class which represents billing details for a service booking in the Vehicle Service Management System.
+             Each invoice includes booking information, labor cost, parts used, discount percentage, total amount, payment details, and status.
+Author: Trenser
+Date: 19-May-2026
+*/
+
+
 #pragma once
 #include <string>
 #include "Map.h"
+#include "Vector.h"
 #include "Timestamp.h"
 #include "Enums.h"
 
@@ -16,22 +26,22 @@ private:
     ServiceBooking* m_booking;
     util::Timestamp m_invoiceDate;
     double m_laborCost;
-    util::Map<int, InventoryItem*> m_parts;
+    util::Vector<std::string> m_partIDs;
+    util::Map<std::string, InventoryItem*> m_parts;
     double m_partsCost;
     double m_discountPercentage;
     double m_totalAmount;
     util::Timestamp m_paymentDate;
     util::PaymentMode m_paymentMethod;
     util::PaymentStatus m_status;
-
 public:
     Invoice();
     Invoice(
         const std::string& bookingId,
         ServiceBooking* booking,
         const util::Timestamp& invoiceDate, 
-        double laborCost, const util::Map<int,
+        double laborCost, 
-        InventoryItem*>& parts,
+        const util::Map<std::string,InventoryItem*>& parts,
         double partsCost,
         double discountPercentage, 
         double totalAmount, 
@@ -39,12 +49,26 @@ public:
         util::PaymentMode paymentMethod, 
         util::PaymentStatus status
     );
+    Invoice(
+        const std::string& id,
+        const std::string& bookingId,
+        const util::Timestamp& invoiceDate,
+        const util::Vector<std::string>& partIDs,
+        double laborCost,
+        double partsCost,
+        double discountPercentage,
+        double totalAmount,
+        const util::Timestamp& paymentDate,
+        util::PaymentMode paymentMethod,
+        util::PaymentStatus status
+    );
     const std::string& getId() const;
     const std::string& getBookingId() const;
     ServiceBooking* getBooking() const;
     const util::Timestamp& getInvoiceDate() const;
     double getLaborCost() const;
-    const util::Map<int, InventoryItem*>& getParts() const;
+    const util::Vector<std::string>& getPartIDs() const;
+    const util::Map<std::string, InventoryItem*>& getParts() const;
     double getPartsCost() const;
     double getDiscountPercentage() const;
     double getTotalAmount() const;
@@ -56,11 +80,14 @@ public:
     void setBooking(ServiceBooking* booking);
     void setInvoiceDate(const util::Timestamp& invoiceDate);
     void setLaborCost(double laborCost);
-    void setParts(const util::Map<int, InventoryItem*>& parts);
+    void setParts(const util::Map<std::string, InventoryItem*>& parts);
     void setPartsCost(double partsCost);
     void setDiscountPercentage(double discountPercentage);
     void setTotalAmount(double totalAmount);
     void setPaymentDate(const util::Timestamp& paymentDate);
     void setPaymentMethod(util::PaymentMode paymentMethod);
     void setStatus(util::PaymentStatus status);
+    std::string serialize() const;
+    static Invoice* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

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

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

@@ -1,13 +1,21 @@
+/*
+File: JobCard.h
+Description: Header file declaring the JobCard class, which represents
+             a service job card containing booking, service, technician,
+             and status details.
+Author: Trenser
+Date:19-May-2026
+*/
+
 #pragma once
 #include <string>
+#include "Enums.h"
 #include "Timestamp.h"
 
 class ServiceBooking;
 class Service;
 class User;
 
-enum class ServiceJobStatus : int;
-
 class JobCard
 {
 private:
@@ -20,9 +28,8 @@ private:
     std::string m_technicianId;
     User* m_technician;
     util::Timestamp m_assignedDate;
-    ServiceJobStatus m_status;
+    util::ServiceJobStatus m_status;
     util::Timestamp m_completionDate;
-
 public:
     JobCard();
     JobCard(const std::string& bookingId,
@@ -32,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;
@@ -43,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);
@@ -53,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

@@ -1,11 +1,42 @@
+/*
+File: Notification.cpp
+Description: Implements the Notification class which represents system notifications in the Vehicle Service Management System.
+             Provides constructors, accessors, and mutators for notification details such as ID, recipient, title, message, and timestamp.
+Author: Trenser
+Date: 19-May-2026
+*/
+
+#include <sstream>
 #include "Notification.h"
+#include "StringHelper.h"
+#include "Factory.h"
 
 int Notification::m_uid = 0;
 
+/*
+Function: Notification
+Description: Default constructor that initializes a new notification with a unique ID and null recipient.
+Parameters:
+    - None
+Returns:
+    - A new Notification object.
+*/
 Notification::Notification()
     : m_id("NOT" + std::to_string(++m_uid)),
     m_recipient(nullptr) {}
 
+/*
+Function: Notification
+Description: Parameterized constructor that initializes a new notification with a unique ID and specified details.
+Parameters:
+    - recipientUserId: ID of the recipient user.
+    - recipient: Pointer to the User object representing the recipient.
+    - title: Title of the notification.
+    - message: Message content of the notification.
+    - createdAt: Timestamp of when the notification was created.
+Returns:
+    - A new Notification object.
+*/
 Notification::Notification(const std::string& recipientUserId, User* recipient, const std::string& title, const std::string& message, const util::Timestamp& createdAt)
     : m_id("NOT" + std::to_string(++m_uid)),
     m_recipientUserId(recipientUserId),
@@ -14,62 +45,243 @@ Notification::Notification(const std::string& recipientUserId, User* recipient,
     m_message(message),
     m_createdAt(createdAt) {}
 
+/*
+Function: Notification (parameterized constructor with ID)
+Description: Initializes a notification with an existing ID, recipient details,
+             title, message, and creation timestamp. Updates UID tracking based on ID.
+Parameters:
+    - id: const std::string&, unique notification ID
+    - recipientUserId: const std::string&, ID of the recipient user
+    - title: const std::string&, notification title
+    - message: const std::string&, notification message
+    - createdAt: const util::Timestamp&, timestamp of creation
+Returns:
+    - A new Notification object
+*/
+Notification::Notification(const std::string& id, const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt)
+    : m_id(id),
+    m_recipientUserId(recipientUserId),
+    m_recipient(nullptr),
+    m_title(title),
+    m_message(message),
+    m_createdAt(createdAt) 
+{
+    int idNumber = util::extractNumber(m_id);
+    if (idNumber > m_uid)
+    {
+        m_uid = idNumber;
+    }
+}
+
+/*
+Function: getId
+Description: Retrieves the unique ID of the notification.
+Returns:
+    - const std::string& representing the notification ID.
+*/
 const std::string& Notification::getId() const 
 {
     return m_id;
 }
 
+/*
+Function: getRecipientUserId
+Description: Retrieves the recipient user ID associated with the notification.
+Returns:
+    - const std::string& representing the recipient user ID.
+*/
 const std::string& Notification::getRecipientUserId() const
 {
     return m_recipientUserId;
 }
 
+/*
+Function: getRecipient
+Description: Retrieves the pointer to the recipient user.
+Returns:
+    - User* representing the recipient.
+*/
 User* Notification::getRecipient() const
 {
     return m_recipient;
 }
 
+/*
+Function: getTitle
+Description: Retrieves the title of the notification.
+Returns:
+    - const std::string& representing the notification title.
+*/
 const std::string& Notification::getTitle() const
 {
     return m_title;
 }
 
+/*
+Function: getMessage
+Description: Retrieves the message content of the notification.
+Returns:
+    - const std::string& representing the notification message.
+*/
 const std::string& Notification::getMessage() const
 {
     return m_message;
 }
 
+/*
+Function: getCreatedAt
+Description: Retrieves the timestamp of when the notification was created.
+Returns:
+    - const util::Timestamp& representing the creation timestamp.
+*/
 const util::Timestamp& Notification::getCreatedAt() const
 {
     return m_createdAt;
 }
 
+/*
+Function: setId
+Description: Sets the unique ID of the notification.
+Parameters:
+    - id: New notification ID string.
+Returns:
+    - void
+*/
 void Notification::setId(const std::string& id)
 {
     m_id = id;
 }
 
+/*
+Function: setRecipientUserId
+Description: Sets the recipient user ID for the notification.
+Parameters:
+    - recipientUserId: New recipient user ID string.
+Returns:
+    - void
+*/
 void Notification::setRecipientUserId(const std::string& recipientUserId)
 {
     m_recipientUserId = recipientUserId;
 }
 
+/*
+Function: setRecipient
+Description: Sets the recipient user pointer for the notification.
+Parameters:
+    - recipient: Pointer to the User object.
+Returns:
+    - void
+*/
 void Notification::setRecipient(User* recipient)
 {
     m_recipient = recipient;
 }
 
+/*
+Function: setTitle
+Description: Sets the title of the notification.
+Parameters:
+    - title: New notification title string.
+Returns:
+    - void
+*/
 void Notification::setTitle(const std::string& title)
 {
     m_title = title;
 }
 
+/*
+Function: setMessage
+Description: Sets the message content of the notification.
+Parameters:
+    - message: New notification message string.
+Returns:
+    - void
+*/
 void Notification::setMessage(const std::string& message)
 {
     m_message = message;
 }
 
+/*
+Function: setCreatedAt
+Description: Sets the timestamp of when the notification was created.
+Parameters:
+    - createdAt: New timestamp value.
+Returns:
+    - void
+*/
 void Notification::setCreatedAt(const util::Timestamp& createdAt)
 {
     m_createdAt = createdAt;
+}
+
+/*
+Function: serialize
+Description: Serializes the notification into a CSV-formatted string.
+Parameters:
+    - None
+Returns:
+    - std::string: Serialized notification record
+*/
+std::string Notification::serialize() const
+{
+    std::ostringstream serializedNotification;
+    serializedNotification << m_id << ','
+        << m_recipientUserId << ','
+        << m_title << ','
+        << m_message << ','
+        << m_createdAt.toString();
+    return serializedNotification.str();
+}
+
+/*
+Function: deserialize
+Description: Deserializes a CSV-formatted string into a Notification object.
+Parameters:
+    - record: const std::string&, serialized notification record
+Returns:
+    - Notification*: Pointer to the deserialized Notification object
+Throws:
+    - std::runtime_error if timestamp parsing fails
+*/
+Notification* Notification::deserialize(const std::string& record)
+{
+    std::string id, recipientUserId, title, message, createdAtTimestampString;
+    std::istringstream serializedNotification(record);
+    getline(serializedNotification, id, ',');
+    getline(serializedNotification, recipientUserId, ',');
+    getline(serializedNotification, title, ',');
+    getline(serializedNotification, message, ',');
+    getline(serializedNotification, createdAtTimestampString, ',');
+    util::Timestamp createdAtTimestamp;
+    try
+    {
+        createdAtTimestamp = util::Timestamp::fromString(createdAtTimestampString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid createdAt timestamp");
+    }
+    return Factory::getObject<Notification>(
+        id,
+        recipientUserId,
+        title,
+        message,
+        createdAtTimestamp
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for notification serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,RecipientID,Title,Message,Timestamp")
+*/
+std::string Notification::getHeaders()
+{
+    return "ID,RecipientID,Title,Message,Timestamp";
 }

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

@@ -1,3 +1,11 @@
+/*
+File: Notification.h
+Description: Declares the Notification class which represents system messages sent to users in the Vehicle Service Management System.
+             Each notification includes a unique ID, recipient details, title, message content, and timestamp of creation.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #pragma once
 #include <string>
 #include "Timestamp.h"
@@ -17,6 +25,7 @@ private:
 public:
     Notification();
     Notification(const std::string& recipientUserId, User* recipient, const std::string& title, const std::string& message, const util::Timestamp& createdAt);
+    Notification(const std::string& id, const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt);
     const std::string& getId() const;
     const std::string& getRecipientUserId() const;
     User* getRecipient() const;
@@ -29,4 +38,7 @@ public:
     void setTitle(const std::string& title);
     void setMessage(const std::string& message);
     void setCreatedAt(const util::Timestamp& createdAt);
+    std::string serialize() const;
+    static Notification* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

@@ -1,65 +1,337 @@
+/*
+File: Service.cpp
+Description: Implements the Service class which represents a vehicle service in the Vehicle Service Management System.
+             Provides constructors, accessors, and mutators for service details such as ID, name, required inventory items,
+             labor cost, and state.
+Author: Trenser
+Date: 19-May-2026
+*/
+
+#include <sstream>
 #include "Service.h"
+#include "InventoryItem.h"
+#include "StringHelper.h"
+#include "Factory.h"
 
 int Service::m_uid = 0;
 
+/*
+Function: Service
+Description: Default constructor that initializes a new service with a unique ID,
+             active state, and zero labor cost.
+Parameters:
+    - None
+Returns:
+    - A new Service object.
+*/
 Service::Service()
     : m_id("SRV" + std::to_string(++m_uid)),
     m_status(util::State::ACTIVE),
     m_laborCost(0.0) {}
 
+/*
+Function: Service
+Description: Parameterized constructor that initializes a new service with a unique ID and specified details.
+Parameters:
+    - name: Name of the service.
+    - requiredInventoryItems: Map of inventory items required for the service.
+    - laborCost: Labor cost associated with the service.
+Returns:
+    - A new Service object.
+*/
 Service::Service(const std::string& name, const util::Map<std::string, InventoryItem*>& requiredInventoryItems, double laborCost)
     : m_id("SRV" + std::to_string(++m_uid)),
     m_name(name),
     m_requiredInventoryItems(requiredInventoryItems),
     m_status(util::State::ACTIVE),
-    m_laborCost(laborCost) {}
+    m_laborCost(laborCost) 
+{
+    int numberOfInventoryItems = m_requiredInventoryItems.getSize();
+    auto inventoryItemPointers = m_requiredInventoryItems.getValues();
+    for (int index = 0; index < numberOfInventoryItems; index++)
+    {
+        m_requiredInventoryItemIDs.push_back(inventoryItemPointers[index]->getId());
+    }
+}
 
+/*
+Function: Service (parameterized constructor with ID)
+Description: Initializes a service with an existing ID, name, inventory item IDs,
+             labor cost, and state. Updates UID tracking based on ID.
+Parameters:
+    - id: const std::string&, unique service ID
+    - name: const std::string&, name of the service
+    - requiredInventoryItemIDs: const util::Vector<std::string>&, IDs of required inventory items
+    - laborCost: double, labor cost of the service
+    - status: util::State, state of the service (ACTIVE/INACTIVE)
+Returns:
+    - A new Service object
+*/
+Service::Service(const std::string& id, const std::string& name, const util::Vector<std::string>& requiredInventoryItemIDs, double laborCost, util::State status)
+    : m_id(id),
+    m_name(name),
+    m_requiredInventoryItemIDs(requiredInventoryItemIDs),
+    m_status(status),
+    m_laborCost(laborCost)
+{
+    int idNumber = util::extractNumber(m_id);
+    if (idNumber > m_uid)
+    {
+        m_uid = idNumber;
+    }
+}
+
+/*
+Function: getId
+Description: Retrieves the unique ID of the service.
+Returns:
+    - const std::string& representing the service ID.
+*/
 const std::string& Service::getId() const
 {
     return m_id;
 }
 
+/*
+Function: getName
+Description: Retrieves the name of the service.
+Returns:
+    - const std::string& representing the service name.
+*/
 const std::string& Service::getName() const
 {
     return m_name;
 }
 
+/*
+Function: getRequiredInventoryItemIDs
+Description: Retrieves the IDs of required inventory items for the service.
+Parameters:
+    - None
+Returns:
+    - const util::Vector<std::string>&: Inventory item IDs
+*/
+const util::Vector<std::string>& Service::getRequiredInventoryItemIDs() const
+{
+    return m_requiredInventoryItemIDs;
+}
+
+/*
+Function: getRequiredInventoryItems
+Description: Retrieves the map of inventory items required for the service.
+Returns:
+    - const util::Map<std::string, InventoryItem*>& representing the required inventory items.
+*/
 const util::Map<std::string, InventoryItem*>& Service::getRequiredInventoryItems() const
 {
     return m_requiredInventoryItems;
 }
 
+/*
+Function: getLaborCost
+Description: Retrieves the labor cost associated with the service.
+Returns:
+    - double representing the labor cost.
+*/
 double Service::getLaborCost() const
 {
     return m_laborCost;
 }
 
+/*
+Function: getState
+Description: Retrieves the current state (ACTIVE/INACTIVE) of the service.
+Returns:
+    - util::State representing the service state.
+*/
 util::State Service::getState() const
 {
     return m_status;
 }
 
+/*
+Function: setId
+Description: Sets the unique ID of the service.
+Parameters:
+    - id: New service ID string.
+Returns:
+    - void
+*/
 void Service::setId(const std::string& id)
 {
     m_id = id;
 }
 
+/*
+Function: setName
+Description: Sets the name of the service.
+Parameters:
+    - name: New service name string.
+Returns:
+    - void
+*/
 void Service::setName(const std::string& name)
 {
     m_name = name;
 }
 
+/*
+Function: setRequiredInventoryItems
+Description: Sets the inventory items required for the service.
+Parameters:
+    - requiredInventoryItems: Map of inventory items.
+Returns:
+    - void
+*/
 void Service::setRequiredInventoryItems(const util::Map<std::string, InventoryItem*>& requiredInventoryItems)
 {
     m_requiredInventoryItems = requiredInventoryItems;
+    m_requiredInventoryItemIDs.clear();
+    int numberOfRequiredInventoryItems = m_requiredInventoryItems.getSize();
+    auto inventoryItemPointers = m_requiredInventoryItems.getValues();
+    for (int index = 0; index < numberOfRequiredInventoryItems; index++)
+    {
+        m_requiredInventoryItemIDs.push_back(inventoryItemPointers[index]->getId());
+    }
 }
 
+/*
+Function: setLaborCost
+Description: Sets the labor cost for the service.
+Parameters:
+    - laborCost: New labor cost value.
+Returns:
+    - void
+*/
 void Service::setLaborCost(double laborCost)
 {
     m_laborCost = laborCost;
 }
 
+/*
+Function: setState
+Description: Sets the state (ACTIVE/INACTIVE) of the service.
+Parameters:
+    - status: New state value.
+Returns:
+    - void
+*/
 void Service::setState(util::State status)
 {
     m_status = status;
+}
+
+/*
+Function: getInventoryItemIDsAsString (static helper)
+Description: Converts a vector of inventory item IDs into a single string separated by '|'.
+Parameters:
+    - inventoryItemIds: const util::Vector<std::string>&, vector of inventory item IDs
+Returns:
+    - std::string: Concatenated inventory item IDs string
+*/
+static std::string getInventoryItemIDsAsString(const util::Vector<std::string>& inventoryItemIds)
+{
+    int numberOfInventoryItems = inventoryItemIds.getSize();
+    std::string inventoryItemIDs;
+    for (int index = 0; index < numberOfInventoryItems; index++)
+    {
+        inventoryItemIDs += inventoryItemIds[index];
+        if (index < numberOfInventoryItems - 1)
+        {
+            inventoryItemIDs += '|';
+        }
+    }
+    return inventoryItemIDs;
+}
+
+/*
+Function: getInventoryItemIDsAsVector (static helper)
+Description: Converts a string of inventory item IDs separated by '|' into a vector.
+Parameters:
+    - inventoryItemIDsString: const std::string&, concatenated inventory item IDs string
+Returns:
+    - util::Vector<std::string>: Vector of inventory item IDs
+*/
+static util::Vector<std::string> getInventoryItemIDsAsVector(const std::string& inventoryItemIDsString)
+{
+    util::Vector<std::string> inventoryItemIDs;
+    std::string inventoryItemID;
+    std::istringstream serializedInventoryItemIDs(inventoryItemIDsString);
+    while (getline(serializedInventoryItemIDs, inventoryItemID, '|'))
+    {
+        inventoryItemIDs.push_back(inventoryItemID);
+    }
+    return inventoryItemIDs;
+}
+
+/*
+Function: serialize
+Description: Serializes the service into a CSV-formatted string.
+Parameters:
+    - None
+Returns:
+    - std::string: Serialized service record
+*/
+std::string Service::serialize() const
+{
+    std::ostringstream serializedService;
+    serializedService << m_id << ','
+        << m_name << ','
+        << getInventoryItemIDsAsString(m_requiredInventoryItemIDs) << ','
+        << m_laborCost << ','
+        << util::getStateString(m_status);
+    return serializedService.str();
+}
+
+/*
+Function: deserialize
+Description: Deserializes a CSV-formatted string into a Service object.
+Parameters:
+    - record: const std::string&, serialized service record
+Returns:
+    - Service*: Pointer to the deserialized Service object
+Throws:
+    - std::runtime_error if labor cost parsing fails
+*/
+Service* Service::deserialize(const std::string& record)
+{
+    std::string id, name;
+    std::string inventoryItemIDsString, laborCostString, statusString;
+    double laborCost;
+    std::istringstream serializedService(record);
+    getline(serializedService, id, ',');
+    getline(serializedService, name, ',');
+    getline(serializedService, inventoryItemIDsString, ',');
+    getline(serializedService, laborCostString, ',');
+    getline(serializedService, statusString, ',');
+    util::Vector<std::string> inventoryItemIDs = getInventoryItemIDsAsVector(inventoryItemIDsString);
+    try
+    {
+        laborCost = std::stod(laborCostString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid labor cost");
+    }
+    util::State status = util::getState(statusString);
+    return Factory::getObject<Service>(
+        id,
+        name,
+        inventoryItemIDs,
+        laborCost,
+        status
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for service serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,Name,InventoryIDs,LaborCost,Status")
+*/
+std::string Service::getHeaders()
+{
+    return "ID,Name,InventoryIDs,LaborCost,Status";
 }

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

@@ -1,6 +1,16 @@
+/*
+File: Service.h
+Description: Declares the Service class which represents a vehicle service in the Vehicle Service Management System.
+             Each service includes a unique ID, name, required inventory items, labor cost, and status.
+Author: Trenser
+Date: 19-May-2026
+*/
+
+
 #pragma once
 #include <string>
 #include "Map.h"
+#include "Vector.h"
 #include "Enums.h"
 
 class InventoryItem;
@@ -11,14 +21,17 @@ private:
     static int m_uid;
     std::string m_id;
     std::string m_name;
+    util::Vector<std::string> m_requiredInventoryItemIDs;
     util::Map<std::string, InventoryItem*> m_requiredInventoryItems;
     double m_laborCost;
     util::State m_status;
 public:
     Service();
     Service(const std::string& name, const util::Map<std::string, InventoryItem*>& requiredInventoryItems, double laborCost);
+    Service(const std::string& id, const std::string& name, const util::Vector<std::string>& requiredInventoryItemIDs, double laborCost, util::State state);
     const std::string& getId() const;
     const std::string& getName() const;
+    const util::Vector<std::string>& getRequiredInventoryItemIDs() const;
     const util::Map<std::string, InventoryItem*>& getRequiredInventoryItems() const;
     double getLaborCost() const;
     util::State getState() const;
@@ -27,4 +40,7 @@ public:
     void setRequiredInventoryItems(const util::Map<std::string, InventoryItem*>& requiredInventoryItems);
     void setLaborCost(double laborCost);
     void setState(util::State status);
+    std::string serialize() const;
+    static Service* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

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

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

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

@@ -1,14 +1,48 @@
+/*
+File: User.cpp
+Description: Implements the User class which represents system users in the Vehicle Service Management System.
+             Provides constructors, destructor, accessors, and mutators for user details such as ID, username,
+             password, name, phone, email, role, state, and notifications.
+Author: Trenser
+Date: 19-May-2026
+*/
+
+#include <sstream>
 #include "User.h"
 #include "Notification.h"
 #include "Enums.h"
+#include "Factory.h"
+#include "StringHelper.h"
 
 int User::m_uid = 0;
 
+/*
+Function: User
+Description: Default constructor that initializes a new user with a unique ID,
+             default role as CUSTOMER, and active state.
+Parameters:
+    - None
+Returns:
+    - A new User object.
+*/
 User::User()
     : m_id("USR" + std::to_string(++m_uid)),
     m_type(util::UserType::CUSTOMER),
     m_status(util::State::ACTIVE) {}
 
+/*
+Function: User
+Description: Parameterized constructor that initializes a new user with a unique ID and specified details.
+Parameters:
+    - userName: Username for login.
+    - password: Password for authentication.
+    - name: Full name of the user.
+    - phone: Phone number of the user.
+    - email: Email address of the user.
+    - role: Role of the user (CUSTOMER, ADMIN, TECHNICIAN, etc.).
+Returns:
+    - A new User object.
+*/
 User::User(const std::string& userName, const std::string& password, const std::string& name, const std::string& phone, const std::string& email, util::UserType role)
     : m_id("USR" + std::to_string(++m_uid)),
     m_userName(userName),
@@ -19,104 +53,339 @@ User::User(const std::string& userName, const std::string& password, const std::
     m_type(role),
     m_status(util::State::ACTIVE) {}
 
-User::~User()
+/*
+Function: User (parameterized constructor with ID)
+Description: Initializes a user with an existing ID, credentials, personal details,
+             role, and state. Updates UID tracking based on ID.
+Parameters:
+    - userId: const std::string&, unique user ID
+    - userName: const std::string&, username
+    - password: const std::string&, password
+    - name: const std::string&, full name
+    - phone: const std::string&, phone number
+    - email: const std::string&, email address
+    - role: util::UserType, role of the user
+    - status: util::State, state of the user (ACTIVE/INACTIVE)
+Returns:
+    - A new User object
+*/
+User::User(const std::string& userId, const std::string& userName, const std::string& password, const std::string& name, const std::string& phone, const std::string& email, util::UserType role, util::State status)
+    : m_id(userId),
+    m_userName(userName),
+    m_password(password),
+    m_name(name),
+    m_phone(phone),
+    m_email(email),
+    m_type(role),
+    m_status(status)
 {
-    for (int index = 0; index < m_notifications.getSize(); index++)
+    int idNumber = util::extractNumber(m_id);
+    if (idNumber > m_uid)
     {
-        delete m_notifications.getValues()[index];
+        m_uid = idNumber;
     }
 }
 
+/*
+Function: ~User
+Description: Destructor that cleans up dynamically allocated notifications associated with the user.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+User::~User()
+{
+    auto values = m_notifications.getValues();
+    for (int index = 0; index < values.getSize(); index++)
+    {
+        delete values[index];
+    }
+}
+
+/*
+Function: getId
+Description: Retrieves the unique ID of the user.
+Returns:
+    - const std::string& representing the user ID.
+*/
 const std::string& User::getId() const
 {
     return m_id;
 }
 
+/*
+Function: getUserName
+Description: Retrieves the username of the user.
+Returns:
+    - const std::string& representing the username.
+*/
 const std::string& User::getUserName() const
 {
     return m_userName;
 }
 
+/*
+Function: getPassword
+Description: Retrieves the password of the user.
+Returns:
+    - const std::string& representing the password.
+*/
 const std::string& User::getPassword() const
 {
     return m_password;
 }
 
+/*
+Function: getName
+Description: Retrieves the full name of the user.
+Returns:
+    - const std::string& representing the name.
+*/
 const std::string& User::getName() const
 {
     return m_name;
 }
 
+/*
+Function: getPhone
+Description: Retrieves the phone number of the user.
+Returns:
+    - const std::string& representing the phone number.
+*/
 const std::string& User::getPhone() const
 {
     return m_phone;
 }
 
+/*
+Function: getEmail
+Description: Retrieves the email address of the user.
+Returns:
+    - const std::string& representing the email.
+*/
 const std::string& User::getEmail() const
 {
     return m_email;
 }
 
+/*
+Function: getNotifications
+Description: Retrieves the map of notifications associated with the user.
+Returns:
+    - util::Map<std::string, Notification*>& representing the notifications.
+*/
 util::Map<std::string, Notification*>& User::getNotifications()
 {
     return m_notifications;
 }
 
+/*
+Function: getUserType
+Description: Retrieves the role of the user.
+Returns:
+    - util::UserType representing the user role.
+*/
 util::UserType User::getUserType() const
 {
     return m_type;
 }
 
+/*
+Function: getState
+Description: Retrieves the current state (ACTIVE/INACTIVE) of the user.
+Returns:
+    - util::State representing the user state.
+*/
 util::State User::getState() const
 {
     return m_status;
 }
 
+/*
+Function: setId
+Description: Sets the unique ID of the user.
+Parameters:
+    - id: New user ID string.
+Returns:
+    - void
+*/
 void User::setId(const std::string& id)
 {
     m_id = id;
 }
 
+/*
+Function: setUserName
+Description: Sets the username of the user.
+Parameters:
+    - userName: New username string.
+Returns:
+    - void
+*/
 void User::setUserName(const std::string& userName)
 {
     m_userName = userName;
 }
 
+/*
+Function: setPassword
+Description: Sets the password of the user.
+Parameters:
+    - password: New password string.
+Returns:
+    - void
+*/
 void User::setPassword(const std::string& password)
 {
     m_password = password;
 }
 
+/*
+Function: setName
+Description: Sets the full name of the user.
+Parameters:
+    - name: New name string.
+Returns:
+    - void
+*/
 void User::setName(const std::string& name)
 {
     m_name = name;
 }
 
+/*
+Function: setPhone
+Description: Sets the phone number of the user.
+Parameters:
+    - phone: New phone number string.
+Returns:
+    - void
+*/
 void User::setPhone(const std::string& phone)
 {
     m_phone = phone;
 }
 
+/*
+Function: setEmail
+Description: Sets the email address of the user.
+Parameters:
+    - email: New email string.
+Returns:
+    - void
+*/
 void User::setEmail(const std::string& email)
 {
     m_email = email;
 }
 
+/*
+Function: addNotification
+Description: Adds a new notification to the user’s notification map.
+Parameters:
+    - notification: Pointer to the Notification object.
+Returns:
+    - void
+*/
 void User::addNotification(Notification* notification)
 {
-    m_notifications.insert(notification->getId(), notification);
+    if (notification)
+    {
+        m_notifications.insert(notification->getId(), notification);
+    }
 }
 
+/*
+Function: setRole
+Description: Sets the role of the user.
+Parameters:
+    - role: New user role value.
+Returns:
+    - void
+*/
 void User::setRole(util::UserType role)
 {
     m_type = role;
 }
 
+/*
+Function: setState
+Description: Sets the state (ACTIVE/INACTIVE) of the user.
+Parameters:
+    - status: New state value.
+Returns:
+    - void
+*/
 void User::setState(util::State status)
 {
     m_status = status;
 }
 
-void User::update(Notification* notification)
+/*
+Function: serialize
+Description: Serializes the user into a CSV-formatted string.
+Parameters:
+    - None
+Returns:
+    - std::string: Serialized user record
+*/
+std::string User::serialize() const
 {
+    std::ostringstream serializedUser;
+    serializedUser << m_id << ','
+        << m_userName << ','
+        << m_password << ','
+        << m_name << ','
+        << m_phone << ','
+        << m_email << ','
+        << util::getUserTypeString(m_type) << ','
+        << util::getStateString(m_status);
+    return serializedUser.str();
 }
+
+/*
+Function: deserialize
+Description: Deserializes a CSV-formatted string into a User object.
+Parameters:
+    - record: const std::string&, serialized user record
+Returns:
+    - User*: Pointer to the deserialized User object
+*/
+User* User::deserialize(const std::string& record)
+{
+    std::string id, name, username, phone, password, email;
+    std::string userTypeString, stateString;
+    std::istringstream serializedUser(record);
+    getline(serializedUser, id, ',');
+    getline(serializedUser, username, ',');
+    getline(serializedUser, password, ',');
+    getline(serializedUser, name, ',');
+    getline(serializedUser, phone, ',');
+    getline(serializedUser, email, ',');
+    getline(serializedUser, userTypeString, ',');
+    getline(serializedUser, stateString);
+    util::UserType userType = util::getUserType(userTypeString);
+    util::State status = util::getState(stateString);
+    return Factory::getObject<User>(id,
+        username,
+        password,
+        name,
+        phone,
+        email,
+        userType,
+        status);
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for user serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,Username,Password,Name,Phone,Email,UserType,UserStatus")
+*/
+std::string User::getHeaders()
+{
+    return "ID,Username,Password,Name,Phone,Email,UserType,UserStatus";
+}

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

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

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

@@ -1,3 +1,82 @@
+/*
+File: AuthenticationManagementService.cpp
+Description: Implementation file containing the method definitions of the
+			 AuthenticationManagementService class, including logout and
+			 password change logic.
+Author: Trenser
+Date:19-May-2026
+*/
+
+#include <stdexcept>
 #include "AuthenticationManagementService.h"
+#include "User.h"
 
 User* AuthenticationManagementService::m_authenticatedUser = nullptr;
+
+/*
+Function: login
+Description: Authenticates a user by checking the provided username and password
+			 against the stored users in the DataStore. If successful, sets the
+			 authenticated user.
+Parameter: const std::string& username - user’s username
+		   const std::string& password - user’s password
+Return type: bool - true if login successful, false otherwise
+*/
+bool AuthenticationManagementService::login(const std::string& username, const std::string& password)
+{
+	util::Map<std::string, User*> users = m_dataStore.getUsers();
+	int usersMapSize = users.getSize();
+	for (int index = 0; index < usersMapSize; index++)
+	{
+		User* user = users.getValueAt(index);
+		if (username == user->getUserName())
+		{
+			if (password == user->getPassword())
+			{
+				m_authenticatedUser = user;
+				return true;
+			}
+			return false;
+		}
+	}
+	return false;
+}
+
+/*
+Function: getAuthenticatedUser
+Description: Retrieves the currently authenticated user.
+Parameter: None
+Return type: User* - pointer to the authenticated user
+*/
+User* AuthenticationManagementService::getAuthenticatedUser()
+{
+	return m_authenticatedUser;
+}
+
+/*
+Function: logout
+Description: Logs out the currently authenticated user by clearing the
+			 static authenticated user pointer.
+Parameter: None
+Return type: void
+*/
+void AuthenticationManagementService::logout()
+{
+	m_authenticatedUser = nullptr;
+}
+
+/*
+Function: changePassword
+Description: Changes the password of the currently authenticated user.
+			 Throws an exception if no user is logged in.
+Parameter: const std::string& newPassword - new password to set
+Return type: void
+*/
+void AuthenticationManagementService::changePassword(const std::string& newPassword)
+{
+	if (m_authenticatedUser == nullptr)
+	{
+		throw std::runtime_error("There is no user currently logged in!");
+	}
+	m_authenticatedUser->setPassword(newPassword);
+}

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

@@ -1,3 +1,12 @@
+/*
+File: AuthenticationManagementService.h
+Description: Header file declaring the AuthenticationManagementService class, which manages
+             user authentication, login, logout, password changes, and retrieval of the
+             authenticated user.
+Author: Trenser
+Date:19-May-2026
+*/
+
 #pragma once
 #include <string>
 #include "DataStore.h"

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

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

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

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

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

@@ -1,6 +1,15 @@
+/*
+File: NotificationManagementService.h
+Description: Declares the NotificationManagementService abstract class which defines the contract for managing notifications in the Vehicle Service Management System.
+			 Implements the Subject interface and provides pure virtual methods for sending notifications and managing user subscriptions (attach/detach).
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #pragma once
 #include <string>
 #include "Subject.h"
+#include "Notification.h"
 #include "User.h"
 
 class NotificationManagementService : public Subject
@@ -10,4 +19,5 @@ public:
 	virtual void sendNotification(User* recipient, const std::string& title, const std::string& message) = 0;
 	virtual void attach(User* user) = 0;
 	virtual void detach(User* user) = 0;
+	virtual util::Vector<std::string> getObserverIDs() = 0;
 };

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

@@ -1 +1,387 @@
+/*
+File: PaymentManagementService.cpp
+Description: Implements the PaymentManagementService class which manages payment-related operations
+			 in the Vehicle Service Management System. Provides functionality for attaching/detaching observers,
+			 sending notifications, and issuing payment reminders based on invoice status and thresholds.
+Author: Trenser
+Date: 20-May-2026
+*/
+
+#include <stdexcept>
+#include "Config.h"
+#include "Enums.h"
+#include "Factory.h"
+#include "FileManager.h"
+#include "InventoryItem.h"
+#include "Invoice.h"
+#include "JobCard.h"
 #include "PaymentManagementService.h"
+#include "Service.h"
+#include "ServiceBooking.h"
+#include "Timestamp.h"
+#include "User.h"
+#include "Utility.h"
+
+util::Map<std::string, User*> PaymentManagementService::m_observers{};
+
+/*
+Function: attach
+Description: Attaches a user as an observer to the PaymentManagementService for receiving notifications.
+Parameters:
+	- user: Pointer to the User object to be attached.
+Returns:
+	- void
+*/
+void PaymentManagementService::attach(User* user)
+{
+	if (user)
+	{
+		const std::string& userID = user->getId();
+		if (m_observers.find(userID) == -1)
+		{
+			m_observers[userID] = user;
+		}
+	}
+}
+
+/*
+Function: detach
+Description: Detaches a user from the observer list of the PaymentManagementService.
+Parameters:
+	- user: Pointer to the User object to be detached.
+Returns:
+	- void
+*/
+void PaymentManagementService::detach(User* user)
+{
+	if (user)
+	{
+		const std::string& userID = user->getId();
+		if (m_observers.find(userID) != -1)
+		{
+			m_observers.remove(userID);
+		}
+	}
+}
+
+/*
+Function: sendNotification
+Description: Sends a notification to a user if they are registered as an observer.
+Parameters:
+	- user: Pointer to the User object to receive the notification.
+	- title: Title of the notification.
+	- message: Message content of the notification.
+Returns:
+	- void
+Throws:
+	- std::runtime_error if notification creation fails.
+*/
+void PaymentManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
+{
+	if (user)
+	{
+		if (m_observers.find(user->getId()) != -1)
+		{
+			Notification* notification =
+				Factory::getObject<Notification>(
+					user->getId(),
+					user,
+					title,
+					message,
+					util::Timestamp()
+				);
+			if (notification)
+			{
+				user->addNotification(notification);
+			}
+			else
+			{
+				throw std::runtime_error("Failed to create notification");
+			}
+		}
+	}
+}
+
+/*
+Function: sendPaymentReminders
+Description: Iterates through all invoices in the datastore and sends payment reminders to customers
+			 whose invoices are pending beyond the configured threshold duration.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void PaymentManagementService::sendPaymentReminders()
+{
+	auto& invoicesMap = m_dataStore.getInvoices();
+	int invoicesMapSize = invoicesMap.getSize();
+	for (int index = 0; index < invoicesMapSize; index++)
+	{
+		const Invoice* invoice = invoicesMap.getValueAt(index);
+		if (invoice && invoice->getStatus() == util::PaymentStatus::PENDING)
+		{
+			util::Timestamp invoiceCreationTimestamp = invoice->getInvoiceDate();
+			util::Timestamp currentTimestamp;
+			if (util::Timestamp::getDurationInHours(invoiceCreationTimestamp, currentTimestamp) >= config::threshold::PAYMENT_REMINDER_THRESHOLD_HOURS)
+			{
+				const ServiceBooking* serviceBooking = invoice->getBooking();
+				if (serviceBooking)
+				{
+					User* customer = serviceBooking->getCustomer();
+					if (customer)
+					{
+						std::string title = "Payment Reminder";
+						std::string message = "Your payment for Invoice ID " + invoice->getId() + " is still pending. Please complete the payment.";
+						sendNotification(customer, title, message);
+					}
+				}
+			}
+		}
+	}
+}
+
+/*
+Function: getObserverIDs
+Description: Retrieves the IDs of all observers currently attached to the
+             PaymentManagementService.
+Parameters:
+    - None
+Returns:
+    - util::Vector<std::string>: Vector of observer user IDs
+*/
+util::Vector<std::string> PaymentManagementService::getObserverIDs()
+{
+	util::Vector<std::string> observerIDs;
+	int numberOfObservers = m_observers.getSize();
+	for (int index = 0; index < numberOfObservers; index++)
+	{
+		User* observer = m_observers.getValueAt(index);
+		if (observer)
+		{
+			observerIDs.push_back(observer->getId());
+		}
+	}
+	return observerIDs;
+}
+
+/*
+Function: loadInvoices
+Description: Loads invoices from persistent storage into the datastore.
+             Validates associated service bookings and inventory parts before
+             attaching them to each invoice. Throws exceptions if invalid IDs
+             are encountered.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a booking ID or part ID is invalid
+*/
+void PaymentManagementService::loadInvoices()
+{
+    util::FileManager<Invoice> invoiceFileManager(config::file::INVOICE_FILE);
+    auto& invoices = m_dataStore.getInvoices();
+    auto& serviceBookings = m_dataStore.getServiceBookings();
+    auto& inventoryItems = m_dataStore.getInventoryItems();
+    auto invoicesMap = invoiceFileManager.load();
+    for (int invoiceIndex = 0; invoiceIndex < invoicesMap.getSize(); invoiceIndex++)
+    {
+        Invoice* invoice = invoicesMap.getValueAt(invoiceIndex);
+        int bookingIndex = serviceBookings.find(invoice->getBookingId());
+        if (bookingIndex == -1)
+        {
+            throw std::runtime_error("Invalid Booking ID");
+        }
+        ServiceBooking* booking = serviceBookings.getValueAt(bookingIndex);
+        invoice->setBooking(booking);
+        util::Map<std::string, InventoryItem*> invoiceParts;
+        auto& partIDs = invoice->getPartIDs();
+        for (int partIndex = 0; partIndex < partIDs.getSize(); partIndex++)
+        {
+            const std::string& partID = partIDs[partIndex];
+            int inventoryIndex = inventoryItems.find(partID);
+            if (inventoryIndex == -1)
+            {
+                throw std::runtime_error("Invalid Part ID");
+            }
+            invoiceParts[partID] = inventoryItems.getValueAt(inventoryIndex);
+        }
+        invoice->setParts(invoiceParts);
+        invoices[invoice->getId()] = invoice;
+    }
+}
+
+/*
+Function: saveInvoices
+Description: Saves invoices from the datastore to persistent storage.
+             Uses FileManager to serialize invoices into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void PaymentManagementService::saveInvoices()
+{
+    util::FileManager<Invoice> invoiceFileManager(config::file::INVOICE_FILE);
+    auto& invoices = m_dataStore.getInvoices();
+    invoiceFileManager.save(invoices);
+}
+
+/*
+Function: loadObservers
+Description: Loads observer IDs from persistent storage and attaches corresponding
+             users as observers to the PaymentManagementService.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if an observer ID is invalid (not found in datastore)
+*/
+void PaymentManagementService::loadObservers()
+{
+    util::loadObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this, m_dataStore);
+}
+
+/*
+Function: saveObservers
+Description: Saves the current observer IDs of the PaymentManagementService
+             to persistent storage for future retrieval.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void PaymentManagementService::saveObservers()
+{
+    util::saveObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this);
+}
+
+/*
+Function: createInventoryItemsMap (static helper)
+Description: Builds a map of inventory items required for a given service and adds them to the booking’s inventory map.
+Parameters:
+	- completeInventoryItemMapOfBooking: util::Map<std::string, InventoryItem*>&, map to store inventory items for the booking
+	- currentService: const Service*, pointer to the current service
+Returns:
+	- void
+*/
+static void createInventoryItemsMap(util::Map<std::string, InventoryItem*>& completeInventoryItemMapOfBooking, const Service* currentService)
+{
+	auto& currentRequiredInventoryItems = currentService->getRequiredInventoryItems();
+	for (int iterator = 0; iterator < currentRequiredInventoryItems.getSize(); iterator++)
+	{
+		auto& currentRequiredInventoryItem = currentRequiredInventoryItems.getValueAt(iterator);
+		completeInventoryItemMapOfBooking.insert(currentRequiredInventoryItem->getId(), currentRequiredInventoryItem);
+	}
+}
+
+/*
+Function: generateInvoice
+Description: Generates an invoice for a completed service booking.
+			 Validates that all job cards are completed, calculates labor and parts cost, applies discount,
+			 and stores the invoice in the datastore.
+Parameters:
+	- booking: ServiceBooking*, pointer to the service booking
+Returns:
+	- void
+Throws:
+	- std::runtime_error if booking is null or job cards are incomplete
+*/
+void PaymentManagementService::generateInvoice(ServiceBooking* booking)
+{
+	if (!booking)
+	{
+		throw std::runtime_error("Invoice generation failed: booking is null.");
+	}
+	double totalLaborCost = 0, totalPartsCost = 0, totalServiceCost = 0;
+	double discountPercentage = booking->getDiscountPercentage();
+	std::string bookingID = booking->getId();
+	util::Map<std::string, Service*> servicesInTheBookedService = booking->getServices();
+	util::Map<std::string, InventoryItem*> completeInventoryItemMapOfBooking;
+	util::Map<std::string, JobCard*> currentJobCards = m_dataStore.getJobCards();
+	for (int iterator = 0; iterator < currentJobCards.getSize(); iterator++)
+	{
+		JobCard* currentJobCard = currentJobCards.getValueAt(iterator);
+		util::ServiceJobStatus currentJobCardStatus = currentJobCard->getStatus();
+		if (currentJobCard->getBookingId() == bookingID && currentJobCardStatus != util::ServiceJobStatus::CANCELLED && currentJobCardStatus != util::ServiceJobStatus::COMPLETED)
+		{
+			throw std::runtime_error("Invoice generation failed: Not all job cards are completed for booking '" + bookingID + "'.");
+		}
+	}
+	for (int iterator = 0; iterator < servicesInTheBookedService.getSize(); iterator++)
+	{
+		Service* currentService = servicesInTheBookedService.getValueAt(iterator);
+		if (currentService)
+		{
+			createInventoryItemsMap(completeInventoryItemMapOfBooking, currentService);
+			totalLaborCost += currentService->getLaborCost();
+			totalPartsCost += util::calculatePartsCost(currentService);
+		}
+	}
+	totalServiceCost = totalLaborCost + totalPartsCost;
+	totalServiceCost -= (totalServiceCost * (discountPercentage / 100));
+	Invoice* invoice = Factory::getObject<Invoice>(bookingID, booking, util::Timestamp(), totalLaborCost, completeInventoryItemMapOfBooking, totalPartsCost, discountPercentage, totalServiceCost, util::Timestamp(), util::PaymentMode::NOTSET, util::PaymentStatus::PENDING);
+	util::Map<std::string, Invoice*>& currentInvoices = m_dataStore.getInvoices();
+	currentInvoices.insert(invoice->getId(), invoice);
+}
+
+/*
+Function: getInvoices
+Description: Retrieves all invoices associated with a specific customer.
+Parameters:
+	- customerID: std::string, ID of the customer
+Returns:
+	- util::Map<std::string, Invoice*> containing the customer’s invoices
+*/
+util::Map<std::string, Invoice*> PaymentManagementService::getInvoices(const std::string& customerID)
+{
+	util::Map<std::string, Invoice*>& currentInvoices = m_dataStore.getInvoices();
+	util::Map<std::string, Invoice*> currentUserInvoices;
+	for (int iterator = 0; iterator < currentInvoices.getSize(); iterator++)
+	{
+		Invoice* currentInvoice = currentInvoices.getValueAt(iterator);
+		if (currentInvoice->getBooking()->getCustomerId() == customerID)
+		{
+			currentUserInvoices.insert(currentInvoice->getId(), currentInvoice);
+		}
+	}
+	return currentUserInvoices;
+}
+
+/*
+Function: completePayment
+Description: Completes payment for a specific invoice. Updates payment method, date, and status,
+			 then sends a notification to the customer.
+Parameters:
+	- invoiceID: std::string, ID of the invoice
+	- paymentMode: util::PaymentMode, mode of payment (e.g., ONLINE, OFFLINE)
+Returns:
+	- void
+Throws:
+	- std::runtime_error if the invoice ID is invalid
+*/
+void PaymentManagementService::completePayment(const std::string& invoiceID, util::PaymentMode paymentMode)
+{
+	auto& currentInvoices = m_dataStore.getInvoices();
+	int invoiceIndex = currentInvoices.find(invoiceID);
+	if (invoiceIndex != -1)
+	{
+		Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
+		if (invoice && invoice->getStatus() != util::PaymentStatus::COMPLETED)
+		{
+			User* currentUser = invoice->getBooking()->getCustomer();
+			invoice->setPaymentMethod(paymentMode);
+			invoice->setPaymentDate(util::Timestamp());
+			invoice->setStatus(util::PaymentStatus::COMPLETED);
+			std::string title, message;
+			title = "Payment successful";
+			message = "Payment successful for Invoice ID " + invoiceID;
+			sendNotification(currentUser, title, message);
+		}
+	}
+	else
+	{
+		throw std::runtime_error("Payment failed: invalid invoice ID.");
+	}
+}

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

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

@@ -1,3 +1,12 @@
+/*
+File: ServiceManagementService.h
+Description: Header file declaring the ServiceManagementService class, which manages
+             services, combo packages, job cards, and service bookings. Inherits from
+             NotificationManagementService to handle notifications.
+Author: Trenser
+Date:19-May-2026
+*/
+
 #pragma once
 #include <string>
 #include "Map.h"
@@ -14,6 +23,7 @@ class ServiceManagementService : public NotificationManagementService
 private:
     DataStore& m_dataStore;
     static util::Map<std::string, User*> m_observers;
+    util::Vector<std::string> getObserverIDs() override;
 public:
     ServiceManagementService() : m_dataStore(DataStore::getInstance()) {}
     util::Map<std::string, Service*> getServices();
@@ -22,6 +32,7 @@ public:
     void purchaseComboPackage(const std::string& comboPackageID, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel);
     util::Map<std::string, ServiceBooking*> getServiceBookings();
     util::Map<std::string, ServiceBooking*> getServiceBookings(const std::string& customerID);
+    ServiceBooking* getServiceBooking(const std::string& serviceID);
     void createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID);
     void createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost);
     void removeService(const std::string& serviceID);
@@ -29,9 +40,19 @@ public:
     void completeJob(const std::string& jobID);
     void cancelCustomerServiceBookings(const std::string& customerID);
     void cancelTechnicianJobs(const std::string& technicianID);
-    void createComboPackage(const std::string& name, const util::Vector<std::string>& serviceIDs, double discountPercentage);
+    void createComboPackage(const std::string& packageName, const util::Vector<std::string>& serviceIDs, double discountPercentage);
     void removeComboPackage(const std::string& comboPackageID);
     void sendNotification(User* user, const std::string& title, const std::string& message) override;
     void attach(User* user) override;
     void detach(User* user) override;
+    void loadServices();
+    void saveServices();
+    void loadComboPackages();
+    void saveComboPackages();
+    void loadServiceBookings();
+    void saveServiceBookings();
+    void loadJobCards();
+    void saveJobCards();
+    void loadObservers();
+    void saveObservers();
 };

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

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

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

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

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

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

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

@@ -1,3 +1,12 @@
+/*
+File: Enums.h
+Description: Declares enumerations and utility functions for user types, payment modes, payment status,
+             service job status, and state management in the Vehicle Service Management System.
+             Provides string conversion and parsing functions for each enum type.
+Author: Trenser
+Date: 19-May-2026
+*/
+
 #pragma once
 #include <stdexcept>
 
@@ -13,7 +22,8 @@ namespace util
 	enum class PaymentMode
 	{
 		ONLINE,
-		OFFLINE
+		OFFLINE,
+        NOTSET
 	};
 
 	enum class PaymentStatus
@@ -24,8 +34,10 @@ namespace util
 
 	enum class ServiceJobStatus
 	{
+        PENDING,
 		STARTED,
-		COMPLETED
+		COMPLETED,
+        CANCELLED
 	};
 
     enum class State
@@ -34,6 +46,14 @@ namespace util
         INACTIVE
     };
 
+    /*
+    Function: getUserTypeString
+    Description: Converts a UserType enum value to its corresponding string representation.
+    Parameters:
+        - type: UserType enum value.
+    Returns:
+        - std::string representing the UserType.
+    */
     inline std::string getUserTypeString(UserType type)
     {
         switch (type)
@@ -48,6 +68,16 @@ namespace util
         throw std::invalid_argument("Invalid UserType");
     }
 
+    /*
+    Function: getUserType
+    Description: Converts a string value to its corresponding UserType enum.
+    Parameters:
+        - value: std::string representing the UserType.
+    Returns:
+        - UserType enum value.
+    Throws:
+        - std::invalid_argument if the string does not match a valid UserType.
+    */
     inline UserType getUserType(const std::string& value)
     {
         if (value == "ADMIN")
@@ -65,6 +95,14 @@ namespace util
         throw std::invalid_argument("Invalid UserType string");
     }
 
+    /*
+    Function: getPaymentModeString
+    Description: Converts a PaymentMode enum value to its corresponding string representation.
+    Parameters:
+        - mode: PaymentMode enum value.
+    Returns:
+        - std::string representing the PaymentMode.
+    */
     inline std::string getPaymentModeString(PaymentMode mode)
     {
         switch (mode)
@@ -73,10 +111,22 @@ namespace util
             return "ONLINE";
         case PaymentMode::OFFLINE:
             return "OFFLINE";
+        case PaymentMode::NOTSET:
+            return "NOTSET";
         }
         throw std::invalid_argument("Invalid PaymentMode");
     }
 
+    /*
+    Function: getPaymentMode
+    Description: Converts a string value to its corresponding PaymentMode enum.
+    Parameters:
+        - value: std::string representing the PaymentMode.
+    Returns:
+        - PaymentMode enum value.
+    Throws:
+        - std::invalid_argument if the string does not match a valid PaymentMode.
+    */
     inline PaymentMode getPaymentMode(const std::string& value)
     {
         if (value == "ONLINE")
@@ -87,9 +137,21 @@ namespace util
         {
             return PaymentMode::OFFLINE;
         }
+        if (value == "NOTSET")
+        {
+            return PaymentMode::NOTSET;
+        }
         throw std::invalid_argument("Invalid PaymentMode string");
     }
 
+    /*
+    Function: getPaymentStatusString
+    Description: Converts a PaymentStatus enum value to its corresponding string representation.
+    Parameters:
+        - status: PaymentStatus enum value.
+    Returns:
+        - std::string representing the PaymentStatus.
+    */
     inline std::string getPaymentStatusString(PaymentStatus status)
     {
         switch (status)
@@ -102,6 +164,16 @@ namespace util
         throw std::invalid_argument("Invalid PaymentStatus");
     }
 
+    /*
+    Function: getPaymentStatus
+    Description: Converts a string value to its corresponding PaymentStatus enum.
+    Parameters:
+        - value: std::string representing the PaymentStatus.
+    Returns:
+        - PaymentStatus enum value.
+    Throws:
+        - std::invalid_argument if the string does not match a valid PaymentStatus.
+    */
     inline PaymentStatus getPaymentStatus(const std::string& value)
     {
         if (value == "PENDING")
@@ -117,18 +189,40 @@ namespace util
         throw std::invalid_argument("Invalid PaymentStatus string");
     }
 
+    /*
+    Function: getServiceJobStatusString
+    Description: Converts a ServiceJobStatus enum value to its corresponding string representation.
+    Parameters:
+        - status: ServiceJobStatus enum value.
+    Returns:
+        - std::string representing the ServiceJobStatus.
+    */
     inline std::string getServiceJobStatusString(ServiceJobStatus status)
     {
         switch (status)
         {
+        case ServiceJobStatus::PENDING:
+            return "PENDING";
         case ServiceJobStatus::STARTED:
             return "STARTED";
         case ServiceJobStatus::COMPLETED:
             return "COMPLETED";
+        case ServiceJobStatus::CANCELLED:
+            return "CANCELLED";
         }
         throw std::invalid_argument("Invalid ServiceJobStatus");
     }
 
+    /*
+    Function: getServiceJobStatus
+    Description: Converts a string value to its corresponding ServiceJobStatus enum.
+    Parameters:
+        - value: std::string representing the ServiceJobStatus.
+    Returns:
+        - ServiceJobStatus enum value.
+    Throws:
+        - std::invalid_argument if the string does not match a valid ServiceJobStatus.
+    */
     inline ServiceJobStatus getServiceJobStatus(const std::string& value)
     {
         if (value == "STARTED")
@@ -139,31 +233,57 @@ namespace util
         {
             return ServiceJobStatus::COMPLETED;
         }
+        if (value == "PENDING")
+        {
+            return ServiceJobStatus::PENDING;
+        }
+        if (value == "CANCELLED")
+        {
+            return ServiceJobStatus::CANCELLED;
+        }
         throw std::invalid_argument("Invalid ServiceJobStatus string");
     }
 
+    /*
+    Function: getStateString
+    Description: Converts a State enum value to its corresponding string representation.
+    Parameters:
+        - status: State enum value.
+    Returns:
+        - std::string representing the State.
+    */
     inline std::string getStateString(State status)
     {
         switch (status)
         {
         case State::ACTIVE:
-            return "STARTED";
+            return "ACTIVE";
         case State::INACTIVE:
-            return "COMPLETED";
+            return "INACTIVE";
         }
         throw std::invalid_argument("Invalid State");
     }
 
+    /*
+    Function: getState
+    Description: Converts a string value to its corresponding State enum.
+    Parameters:
+        - value: std::string representing the State.
+    Returns:
+        - State enum value.
+    Throws:
+        - std::invalid_argument if the string does not match a valid State.
+    */
     inline State getState(const std::string& value)
     {
         if (value == "ACTIVE")
         {
             return State::ACTIVE;
         }
-        if (value == "COMPLETED")
+        if (value == "INACTIVE")
         {
             return State::INACTIVE;
         }
         throw std::invalid_argument("Invalid State string");
     }
-}
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,89 +1,706 @@
-#include "AdminMenu.h"
+/*
-#include "InputHelper.h"
+File: AdminMenu.cpp
-#include "OutputHelper.h"
+Description: Implements the AdminMenu class which provides the administrator’s console interface
+			 in the Vehicle Service Management System. Handles menu display, user input, and
+			 admin-specific operations such as inventory management, technician management,
+			 service creation, combo package management, job assignment, and notifications.
+Author: Trenser
+Date: 19-May-2026
+*/
 
+#include <iomanip>
+#include <iostream>
+#include "AdminMenu.h"
+#include "Enums.h"
+#include "InputHelper.h"
+#include "InventoryItem.h"
+#include "MenuHelper.h"
+#include "OutputHelper.h"
+#include "Service.h"
+#include "ServiceBooking.h"
+#include "User.h"
+#include "Utility.h"
+#include "Validator.h"
+
+/*
+Function: showMenu
+Description: Displays the admin menu and handles user input until logout is selected.
+Parameter: None
+Return type: void
+*/
 void AdminMenu::showMenu()
 {
-	bool isMenuActive = true;
+    while (true)
-	while (isMenuActive)
+    {
-	{
+        try
-		try
+        {
-		{
+            int choice;
-			int choice;
+            util::clear();
-			util::clear();
+            std::cout << "Admin Menu"
-			std::cout << "" << std::endl;
+                << "\n1. View Stock Levels"
-			util::read(choice);
+                << "\n2. Add Inventory Item"
-			if (!handleOperation(choice))
+                << "\n3. Remove Inventory Item"
-			{
+                << "\n4. Check Stock Availability"
-				isMenuActive = false;
+                << "\n5. Assign Job to Technician"
-			}
+                << "\n6. Display Users"
-		}
+                << "\n7. Add Technician"
-		catch (const std::exception& e)
+                << "\n8. Remove Customer/Technician"
-		{
+                << "\n9. Display Services"
-			std::cout << "Exception: " << e.what() << std::endl;
+                << "\n10. Create Service"
-			util::pressEnter();
+                << "\n11. Remove Service"
-		}
+                << "\n12. Display Combo Packages"
-	}
+                << "\n13. Create Combo Package"
+                << "\n14. Remove Combo Package"
+                << "\n15. View Notifications"
+                << "\n16. Change Password"
+                << "\n17. Logout"
+                << "\nEnter a choice: ";
+            util::read(choice);
+            if (!handleOperation(choice))
+            {
+                break;
+            }
+        }
+        catch (const std::exception& e)
+        {
+            std::cout << "Exception: " << e.what() << std::endl;
+            util::pressEnter();
+        }
+    }
 }
 
+/*
+Function: handleOperation
+Description: Executes the corresponding admin operation based on the selected menu choice.
+Parameter: int choice - selected menu option
+Return type: bool - true if menu continues, false if logout
+*/
 bool AdminMenu::handleOperation(int choice)
 {
-	return false;
+    switch (choice)
+    {
+    case 1:
+        viewStockLevels();
+        break;
+    case 2:
+        addInventoryItem();
+        break;
+    case 3:
+        removeInventoryItem();
+        break;
+    case 4:
+        checkStockAvailability();
+        break;
+    case 5:
+        assignJob();
+        break;
+    case 6:
+        displayUsers();
+        break;
+    case 7:
+        addTechnician();
+        break;
+    case 8:
+        removeUser();
+        break;
+    case 9:
+        displayServices();
+        break;
+    case 10:
+        createService();
+        break;
+    case 11:
+        removeService();
+        break;
+    case 12:
+        displayComboPackages();
+        break;
+    case 13:
+        createComboPackages();
+        break;
+    case 14:
+        removeComboPackage();
+        break;
+    case 15:
+        viewNotifications();
+        break;
+    case 16:
+        changePassword();
+        break;
+    case 17:
+        logout();
+        return false;
+    default:
+        std::cout << "Enter a valid choice!" << std::endl;
+        util::pressEnter();
+    }
+    return true;
 }
 
-
+/*
+Function: logout
+Description: Logs out the currently authenticated admin user.
+Parameter: None
+Return type: void
+*/
 void AdminMenu::logout()
 {
+	m_controller.logout();
 }
 
+/*
+Function: changePassword
+Description: Allows the admin to change their password after validation.
+Parameter: None
+Return type: void
+*/
 void AdminMenu::changePassword()
 {
+	changePasswordHelper(m_controller);
 }
 
+/*
+Function: viewStockLevels
+Description: Displays all active inventory items with their details
+             including ID, part name, quantity, and price.
+Parameter: None
+Return type: void
+*/
 void AdminMenu::viewStockLevels()
 {
+    util::clear();
+	auto inventoryItems = m_controller.getInventoryItems();
+	bool hasActiveItems = false;
+	std::cout << "View Stock Levels" << std::endl;
+	if (inventoryItems.isEmpty())
+	{
+		std::cout << "No items found in Inventory.\n";
+		util::pressEnter();
+		return;
+	}
+	for (int index = 0; index < inventoryItems.getSize(); index++)
+	{
+		const InventoryItem* item = inventoryItems.getValueAt(index);
+		if (item->getState() == util::State::ACTIVE)
+		{
+			hasActiveItems = true;
+			break;
+		}
+	}
+	if (!hasActiveItems)
+	{
+		std::cout << "No active Inventory Item found.\n";
+		util::pressEnter();
+		return;
+	}
+	std::cout << std::left << std::setw(15) << "Item ID"
+		<< std::setw(25) << "Part Name"
+		<< std::setw(15) << "Quantity"
+		<< std::setw(15) << "Price"
+		<< std::endl;
+	for (int iterator = 0; iterator < inventoryItems.getSize(); ++iterator)
+	{
+		const InventoryItem* item = inventoryItems.getValueAt(iterator);
+		if (item != nullptr)
+		{
+			if (item->getState() != util::State::INACTIVE)
+			{
+				std::cout << std::left << std::setw(15) << item->getId()
+					<< std::setw(25) << item->getPartName()
+					<< std::setw(15) << item->getQuantity()
+					<< std::setw(15) << item->getPrice()
+					<< std::endl;
+			}
+		}
+	}
+	std::cout << "\n";
+	util::pressEnter();
 }
 
+/*
+Function: addInventoryItem
+Description: Allows the admin to either add a new inventory item
+             or increase the quantity of an existing item.
+Parameter: None
+Return type: void
+*/
 void AdminMenu::addInventoryItem()
 {
+	util::clear();
+	int choice, quantity;
+	double price;
+	std::string partName;
+	std::cout << "Add Inventory Item\n";
+	std::cout << "1. Add new item \n2. Restock Item\n\nEnter your choice : ";
+	util::read(choice);
+	switch (choice)
+	{
+	case 1:
+	{
+		util::clear();
+		std::cout << "Enter Item Details\n";
+		std::cout << "Part Name : ";
+		util::read(partName);
+		std::cout << "Quantity : ";
+		util::read(quantity);
+		std::cout << "Price : ";
+		util::read(price);
+		m_controller.addInventoryItem(partName, quantity, price);
+		std::cout << "\nNew Item " << partName << " added to the Inventory.\n\n";
+		break;
+	}
+	case 2:
+	{
+		util::clear();
+		std::cout << "Select Item to Restock\n";
+		auto inventoryItems = m_controller.getInventoryItems();
+		addQuantityToItem(inventoryItems, m_controller);
+		break;
+	}
+	default:
+	{
+		std::cout << "\nEnter a valid choice.\n\n";
+	}
+	}
+	util::pressEnter();
 }
 
+/*
+Function: removeInventoryItem
+Description: Removes an active inventory item by marking it inactive
+             after user selection.
+Parameter: None
+Return type: void
+*/
 void AdminMenu::removeInventoryItem()
 {
+    util::clear();
+	std::cout << "Remove Inventory Item\n";
+    auto inventoryItems = m_controller.getInventoryItems();
+    auto activeItems = filterActiveItems(inventoryItems);
+    int activeItemsSize = activeItems.getSize();
+    if (activeItemsSize == 0)
+    {
+        std::cout << "No items available in Inventory." << std::endl;
+        util::pressEnter();
+        return;
+    }
+    displayInventoryWithItems(activeItems);
+    int itemIndex;
+    std::cout << "Enter the index of the item to remove: ";
+    util::read(itemIndex);
+    if (itemIndex < 1 || itemIndex > activeItemsSize)
+    {
+        std::cout << "Invalid index selected." << std::endl;
+        util::pressEnter();
+        return;
+    }
+    const InventoryItem* selectedItem = activeItems.getValueAt(itemIndex - 1);
+    if (selectedItem != nullptr)
+    {
+        if(selectedItem->getState() != util::State::INACTIVE)
+        {
+            std::string selectedItemId = selectedItem->getId();
+            m_controller.removeInventoryItem(selectedItemId);
+            std::cout << "Item " << selectedItem->getPartName() << " removed successfully." << std::endl;
+        }
+    }
+    util::pressEnter();
 }
 
+/*
+Function: checkStockAvailability
+Description: Checks if a specific inventory item is available
+             and displays its details if active.
+Parameter: None
+Return type: void
+*/
 void AdminMenu::checkStockAvailability()
 {
+	util::clear();
+	std::string itemId;
+	std::cout << "Check Stock Availability \n";
+	std::cout << "Enter the Item ID : ";
+	util::read(itemId);
+	util::clear();
+	const InventoryItem* selectedItem = m_controller.getInventoryItem(itemId);
+	if (selectedItem != nullptr)
+	{
+		if (selectedItem->getState() != util::State::INACTIVE)
+		{
+			std::cout << "Item Details\n";
+			std::cout << "---------------------------------------------\n";
+			std::cout << "Item ID      : " << selectedItem->getId() << "\n";
+			std::cout << "Part Name    : " << selectedItem->getPartName() << "\n";
+			std::cout << "Quantity     : " << selectedItem->getQuantity() << "\n";
+		}
+	}
+	else
+	{
+		std::cout << "Item not Found" << std::endl;
+	}
+	util::pressEnter();
 }
 
+/*
+Function: assignJob
+Description: Allows the admin to assign pending service bookings to available technicians.
+			 Creates job cards for selected services.
+Parameters:
+	- None
+Returns:
+	- void
+*/
 void AdminMenu::assignJob()
 {
+	util::clear();
+	std::cout << "Assign Job to Technician\n";
+	std::string selectedService;
+	bool hasPendingService = false;
+	auto currentBookings = m_controller.getServiceBookings();
+	auto pendingServiceBookings = filterActiveServiceBookings(currentBookings);
+	auto availableTechnicians = m_controller.getUsers(util::UserType::TECHNICIAN);
+	int bookingsSize = pendingServiceBookings.getSize();
+	util::Map<int, const ServiceBooking*> serviceBookingsMap;
+	util::Map<int, const User*> currentAvailableTechniciansMap;
+	if (listServiceBookings(pendingServiceBookings, bookingsSize, serviceBookingsMap))
+	{
+		const ServiceBooking* selectedService = selectPendingServiceBookings(serviceBookingsMap);
+		if (selectedService)
+		{
+			if (availableTechnicians.getSize() != 0)
+			{
+				listAvailableTechnicians(availableTechnicians, availableTechnicians.getSize(), currentAvailableTechniciansMap);
+				const User* selectedTechnician = selectTechnician(currentAvailableTechniciansMap);
+				if (selectedTechnician)
+				{
+					auto& servicesInBooking = selectedService->getServices();
+					for (int iterator = 0; iterator < servicesInBooking.getSize(); iterator++)
+					{
+						m_controller.createJobCard(selectedService->getId(), selectedTechnician->getId(), servicesInBooking.getValueAt(iterator)->getId());
+					}
+					std::cout << "Job card created for each service and technician successfully assigned.\n\n";
+				}
+			}
+			else
+			{
+				std::cout << "No technicians are currently available.\n\n";
+			}
+		}
+	}
+	else
+	{
+		std::cout << "No pending service bookings available.\n\n";
+	}
+	util::pressEnter();
 }
 
+/*
+Function: displayServices()
+Description: Display all active services
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void AdminMenu::displayServices()
+{
+	util::clear();
+	std::cout << "List of all Services\n";
+	util::Map<std::string, const Service*> currentServices = m_controller.getServices();
+	util::Map<std::string, const Service*> currentActiveServices = filterActiveServices(currentServices);
+	displayAllServices(currentActiveServices);
+	util::pressEnter();
+}
+
+/*
+Function: createService
+Description: Allows the admin to create a new service by selecting inventory items and specifying labor cost.
+Parameters:
+	- None
+Returns:
+	- void
+*/
 void AdminMenu::createService()
 {
+	util::clear();
+	std::cout << "Create Service\n";
+	std::string serviceName;
+	double labourCost;
+	std::cout << "Enter the service name: ";
+	util::read(serviceName);
+	util::Map<std::string, const InventoryItem*> currentInventoryItems = m_controller.getInventoryItems();
+	util::Map<std::string, const InventoryItem*> activeInventoryItems = filterActiveItems(currentInventoryItems);
+	util::Vector<std::string> selectedInventoryItems;
+	selectInventoryItems(activeInventoryItems,selectedInventoryItems);
+	if (selectedInventoryItems.isEmpty())
+	{
+		util::pressEnter();
+		return;
+	}
+	std::cout << "\nEnter the labour cost: ";
+	util::read(labourCost);
+    m_controller.createService(serviceName, selectedInventoryItems, labourCost);
+    std::cout << "\nService created sucessfully.\n\n";
+	util::pressEnter();
 }
 
+/*
+Function: removeService
+Description: Allows the admin to remove an existing service by selecting from available services.
+Parameters:
+	- None
+Returns:
+	- void
+*/
 void AdminMenu::removeService()
 {
+	util::clear();
+	std::cout << "Remove Service\n";
+	std::string selectedServiceID;
+	util::Map<std::string, const Service*> currentServices = m_controller.getServices();
+	util::Map<std::string, const Service*> currentActiveServices = filterActiveServices(currentServices);
+	selectedServiceID = selectServicesToRemove(currentActiveServices);
+	if (selectedServiceID != "")
+	{
+		m_controller.removeService(selectedServiceID);
+		std::cout << "Service removed successfully.\n\n";
+	}
+	else
+	{
+		std::cout << "Failed  to remove service.\n\n";
+	}
+	util::pressEnter();
 }
 
+/*
+Function: displayUsers
+Description: Displays all users.
+Parameter: None
+Return type: void
+*/
+void AdminMenu::displayUsers()
+{
+	util::clear();
+	auto listOfUsers = m_controller.getUsers();
+	auto listOfActiveUsers = filterActiveUsers(listOfUsers);
+	int activeUserCount = listOfActiveUsers.getSize();
+	std::cout << "List of all Users\n";
+	if (activeUserCount < 1)
+	{
+		std::cout << "No Active users." << std::endl;
+		util::pressEnter();
+		return;
+	}
+	displayAllUsers(listOfActiveUsers);
+	util::pressEnter();
+}
+
+/*
+Function: addTechnician
+Description: Adds a new technician after validating username, password, email, and phone number.
+Parameter: None
+Return type: void
+*/
 void AdminMenu::addTechnician()
 {
+	util::clear();
+	std::string username, name, password, email, phoneNumber;
+	std::cout << "Add Technician\n";
+	std::cout << "Enter Technician Username: ";
+	util::read(username);
+	std::cout << "Enter Technician Name: ";
+	util::read(name);
+	std::cout << "Enter Technician Password: ";
+	util::read(password);
+	if(!util::isPasswordValid(password))
+	{
+		std::cout << "\nError: Password is invalid!\n\n";
+		util::pressEnter();
+		return;
+	}
+	std::cout << "Enter Technician Email: ";
+	util::read(email);
+	if(!util::isEmailValid(email))
+	{
+		std::cout << "\nError: Email is invalid!\n\n";
+		util::pressEnter();
+		return;
+	}
+	std::cout << "Enter Technician Phone: ";
+	util::read(phoneNumber);
+	if(!util::isPhoneNumberValid(phoneNumber))
+	{
+		std::cout << "\nError: Phone Number is invalid!\n\n";
+		util::pressEnter();
+		return;
+	}
+	m_controller.createTechnician(username, name, password, email, phoneNumber);
+	std::cout << "\nTechnician Added Successfully.\n\n";
+	util::pressEnter();
 }
 
+/*
+Function: removeUser
+Description: Removes a selected active user (customer or technician) from the system.
+Parameter: None
+Return type: void
+*/
 void AdminMenu::removeUser()
 {
+	util::clear();
+	int indexChoice;
+	auto listOfUsers = m_controller.getUsers();
+	auto listOfActiveUsers = filterActiveUsers(listOfUsers);
+	int activeUserCount = listOfActiveUsers.getSize();
+	std::cout << "Remove User \n";
+	if (activeUserCount < 1)
+	{
+		std::cout << "No Active users." << std::endl;
+		util::pressEnter();
+		return;
+	}
+	displayAllUsers(listOfActiveUsers);
+	std::cout << "Enter the index of the user to delete : ";
+	util::read(indexChoice);
+	if (indexChoice < 1 || indexChoice > activeUserCount)
+	{
+		std::cout << "Error invalid index.\n" << std::endl;
+		util::pressEnter();
+		return;
+	}
+	const User* userToRemove = listOfActiveUsers.getValueAt(indexChoice - 1);
+	if (userToRemove != nullptr)
+	{
+		std::string userIdToRemove = userToRemove->getId();
+		m_controller.removeUser(userIdToRemove);
+		std::cout << userToRemove->getUserName() << " removed Successfully.\n";
+	}
+	util::pressEnter();
 }
 
+/*
+Function: displayComboPackages()
+Description: Display all active combo packages
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void AdminMenu::displayComboPackages()
+{
+	util::clear();
+	std::cout << "List of all Combo Packages\n";
+	util::Map<std::string, const ComboPackage*> currentComboPackages = m_controller.getComboPackages();
+	util::Map<std::string, const ComboPackage*> currentActiveComboPackages = filterComboPackages(currentComboPackages);
+	displayAllComboPackages(currentActiveComboPackages);
+	util::pressEnter();
+}
+
+/*
+Function: createComboPackages
+Description: Creates a new combo package by selecting two active services and applying a discount.
+Parameter: None
+Return type: void
+*/
 void AdminMenu::createComboPackages()
 {
+	util::clear();
+	std::cout << "Create Combo Packages\n";
+	auto serviceList = m_controller.getServices();
+	auto activeServices = filterActiveServices(serviceList);
+	int currentActiveServicesCount = activeServices.getSize();
+    const int NUMBER_OF_SERVICE_PER_PACKAGE = 2;
+	util::Vector<std::string> selectedServiceID;
+    for (int iterator = 0; iterator < NUMBER_OF_SERVICE_PER_PACKAGE; iterator++)
+    {
+        const Service* chosenService = nullptr;
+        while (true)
+        {
+            chosenService = selectServiceFromServices(activeServices);
+            if (!chosenService)
+            {
+                std::cout << "Failed to create combo package!\n\n";
+                util::pressEnter();
+                return;
+            }
+            bool alreadyChosen = false;
+            for (int iteratorOne = 0; iteratorOne < selectedServiceID.getSize(); iteratorOne++)
+            {
+                if (selectedServiceID[iteratorOne] == chosenService->getId())
+                {
+                    alreadyChosen = true;
+                    break;
+                }
+            }
+            if (alreadyChosen)
+            {
+				if (currentActiveServicesCount < 2)
+				{
+					break;
+				}
+                std::cout << "Service already selected. Please choose a different one." << std::endl;
+                continue; 
+            }
+            selectedServiceID.push_back(chosenService->getId());
+            break;
+        }
+		if (currentActiveServicesCount < 2)
+		{
+			std::cout << "All the available services selected\n\n";
+			break;
+		}
+    }
+    std::string packageName;
+    double discountPercentage;
+    std::cout << "Enter combo package name: ";
+    util::read(packageName);
+    std::cout << "Enter discount percentage: ";
+    util::read(discountPercentage);
+    if (discountPercentage < 0.0 || discountPercentage > 100.0)
+    {
+        std::cout << "Error: Discount percentage must be between 0 and 100." << std::endl;
+        util::pressEnter();
+        return;
+    }
+    m_controller.createComboPackage(packageName, selectedServiceID, discountPercentage);
+    std::cout << "Combo package '" << packageName << "' created successfully." << std::endl;
+    util::pressEnter();
 }
 
+/*
+Function: removeComboPackage
+Description: Removes a selected combo package from the system.
+Parameter: None
+Return type: void
+*/
 void AdminMenu::removeComboPackage()
 {
+	util::clear();
+	std::cout << "Remove Combo Package\n";
+	util::Map<std::string, const ComboPackage*> currentComboPackages = m_controller.getComboPackages();
+	std::string selectedComboPackageID = selectComboPackage(currentComboPackages);
+	if (!selectedComboPackageID.empty())
+	{
+		m_controller.removeComboPackage(selectedComboPackageID);
+		std::cout << "Combo Package removed successfully.\n\n";
+	}
+	else
+	{
+		std::cout << "Combo package removal failed.\n\n";
+	}
+	util::pressEnter();
 }
 
+/*
+Function: viewNotifications
+Description: Displays notifications for the admin and allows deletion of notifications.
+Parameters:
+	- None
+Returns:
+	- void
+*/
 void AdminMenu::viewNotifications()
 {
+	viewAndDeleteNotification(m_controller);
 }

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

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

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

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

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

@@ -1,3 +1,13 @@
+/*
+File: CustomerMenu.h
+Description: Header file declaring the CustomerMenu class, which provides
+             customer operations such as selecting services, booking combo
+             packages, updating profile details, managing payments, viewing
+             invoices, and configuring notifications.
+Author: Trenser
+Date:19-May-2026
+*/
+
 #pragma once
 #include "Controller.h"
 

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

@@ -1,40 +1,165 @@
-#include "TechnicianMenu.h"
+/*
-#include "InputHelper.h"
+File: TechnicianMenu.cpp
-#include "OutputHelper.h"
+Description: Implementation file containing the method definitions of the
+             TechnicianMenu class, including menu handling, job completion,
+             notification viewing, password management, and logout logic.
+Author: Trenser
+Date:19-May-2026
+*/
 
+#include "Enums.h"
+#include "InputHelper.h"
+#include "JobCard.h"
+#include "MenuHelper.h"
+#include "OutputHelper.h"
+#include "Service.h"
+#include "TechnicianMenu.h"
+#include "Validator.h"
+
+/*
+Function: showMenu
+Description: Displays the technician menu in a loop until the user chooses to logout.
+			 Handles exceptions and ensures smooth user interaction.
+Parameters:
+	- None
+Returns:
+	- void
+*/
 void TechnicianMenu::showMenu()
 {
-	bool isMenuActive = true;
+    while (true)
-	while (isMenuActive)
+    {
-	{
+        try
-		try
+        {
-		{
+            int choice;
-			int choice;
+            util::clear();
-			util::clear();
+            std::cout << "Technician Menu"
-			std::cout << "" << std::endl;
+                << "\n1. Display My Jobs"
-			util::read(choice);
+                << "\n2. Mark Job as Completed"
-			if (!handleOperation(choice))
+                << "\n3. View Notifications"
-			{
+                << "\n4. Change Password"
-				isMenuActive = false;
+                << "\n5. Logout"
-			}
+                << "\nEnter a choice: ";
-		}
+            util::read(choice);
-		catch (const std::exception& e)
+            if (!handleOperation(choice))
-		{
+            {
-			std::cout << "Exception: " << e.what() << std::endl;
+                break;
-			util::pressEnter();
+            }
-		}
+        }
-	}
+        catch (const std::exception& e)
+        {
+            std::cout << "Exception: " << e.what() << std::endl;
+            util::pressEnter();
+        }
+    }
 }
 
+/*
+Function: handleOperation
+Description: Executes the corresponding technician operation based on the selected menu choice.
+Parameter: int choice - selected menu option
+Return type: bool - true if menu continues, false if logout
+*/
 bool TechnicianMenu::handleOperation(int choice)
 {
-	return false;
+    switch (choice)
+    {
+    case 1:
+        displayJobs();
+        break;
+    case 2:
+        completeJob();
+        break;
+    case 3:
+        viewNotifications();
+        break;
+    case 4:
+        changePassword();
+        break;
+    case 5:
+        logout();
+        return false;
+    default:
+        std::cout << "Enter a valid choice!" << std::endl;
+        util::pressEnter();
+    }
+    return true;
 }
 
+/*
+Function: displayJobs
+Description: Displays all Jobs assigned to a Technician
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void TechnicianMenu::displayJobs()
+{
+    util::clear();
+    std::cout << "My Jobs\n";
+    util::Map<std::string, const JobCard*> assignedJobCards = m_controller.getJobCardsByUser();
+    util::Map<std::string, const JobCard*> startedJobCards = filterStartedJobCards(assignedJobCards);
+    displayAllJobs(startedJobCards);
+    util::pressEnter();
+}
+
+/*
+Function: completeJob
+Description: Allows the technician to mark a selected job card as completed.
+             Validates selection and updates job status through the controller.
+Parameters:
+    - None
+Returns:
+    - void
+*/
 void TechnicianMenu::completeJob()
 {
+    util::clear();
+    std::cout << "Complete Job\n";
+	util::Map<std::string, const JobCard*> assignedJobCards = m_controller.getJobCardsByUser();
+    util::Map<std::string, const JobCard*> startedJobCards = filterStartedJobCards(assignedJobCards);
+	std::string selectedJobID = selectJobCardToComplete(startedJobCards);
+    if (!selectedJobID.empty())
+	{
+		m_controller.completeJob(selectedJobID);
+		std::cout << "\nJob marked as completed.\n\n";
+	}
+    util::pressEnter();
 }
 
+/*
+Function: viewNotifications
+Description: Displays notifications for the technician and allows deletion of notifications.
+Parameters:
+	- None
+Returns:
+	- void
+*/
 void TechnicianMenu::viewNotifications()
 {
+	viewAndDeleteNotification(m_controller);
 }
+
+/*
+Function: logout
+Description: Logs out the currently authenticated technician user.
+Parameter: None
+Return type: void
+*/
+void TechnicianMenu::logout()
+{
+	m_controller.logout();
+}
+
+/*
+Function: changePassword
+Description: Allows the technician to change their password after validation.
+Parameter: None
+Return type: void
+*/
+
+void TechnicianMenu::changePassword()
+{
+    changePasswordHelper(m_controller);
+}

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

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

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

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

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

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