Fix PR review comments and refactor menu helper logic

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

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

@@ -233,12 +233,6 @@
     <ClInclude Include="models\ComboPackage.h">
       <Filter>Header Files\Models</Filter>
     </ClInclude>
-    <ClInclude Include="views\MenuHelper.h">
-      <Filter>Header Files\Views</Filter>
-    </ClInclude>
-    <ClInclude Include="utilities\Utility.h">
-      <Filter>Header Files\Utilities</Filter>
-    </ClInclude>
     <ClInclude Include="utilities\Config.h">
       <Filter>Header Files\Utilities</Filter>
     </ClInclude>
@@ -251,5 +245,11 @@
     <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,29 +1,22 @@
 /*
 File: Controller.cpp
-Description: Implementation file containing the method definitions
+Description: Implementation file containing the method definitions of the
-             of the Controller class, which manages user authentication,
+             Controller class, including authentication, user creation,
-             inventory, services, bookings, and notifications.
+             service purchasing, and system checks.
 Author: Trenser
 Date:19-May-2026
 */
-#include "Controller.h"
-#include "ComboPackage.h"
-#include "Enums.h"
-#include "InventoryItem.h"
-#include "Invoice.h"
-#include "JobCard.h"
-#include "Service.h"
-#include "ServiceBooking.h"
-#include "User.h"
-#include "User.h"
 #include <stdexcept>
+#include "Controller.h"
+#include "Enums.h"
+#include "User.h"
 
 /*
 Function: login
-Description: Authenticates a user based on provided credentials.
+Description: Authenticates a user by delegating to the authentication management service.
-Parameter: const std::string& username - the username of the user
+Parameter: const std::string& username - user’s username
-           const std::string& password - the password of the user
+           const std::string& password - user’s password
-Return type: bool
+Return type: bool - true if login successful, false otherwise
 */
 bool Controller::login(const std::string& username, const std::string& password)
 {
@@ -32,8 +25,7 @@ bool Controller::login(const std::string& username, const std::string& password)
 
 /*
 Function: logout
-Description: Logs out the currently authenticated user by delegating
+Description: Logs out the currently authenticated user.
-             to the authentication management service.
 Parameter: None
 Return type: void
 */
@@ -44,9 +36,8 @@ void Controller::logout()
 
 /*
 Function: changePassword
-Description: Updates the password of the authenticated user by delegating
+Description: Changes the password of the currently authenticated user.
-             to the authentication management service.
+Parameter: const std::string& newPassword - new password to set
-Parameter: const std::string& newPassword - the new password to set
 Return type: void
 */
 void Controller::changePassword(const std::string& newPassword)
@@ -54,31 +45,44 @@ void Controller::changePassword(const std::string& newPassword)
     m_authenticationManagementService.changePassword(newPassword);
 }
 
+/*
+Function: createCustomer
+Description: Creates a new customer account with the provided details.
+Parameter: const std::string& username - customer’s username
+           const std::string& name - customer’s name
+           const std::string& password - customer’s password
+           const std::string& email - customer’s email
+           const std::string& phone - customer’s phone number
+Return type: void
+*/
+
 void Controller::createCustomer(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone)
 {
     m_userManagementService.createUser(username, name, password, email, phone, util::UserType::CUSTOMER);
 }
 
+/*
+Function: getAuthenticatedUser
+Description: Retrieves the currently authenticated user.
+Parameter: None
+Return type: const User* - pointer to the authenticated user
+*/
 const User* Controller::getAuthenticatedUser()
 {
     return m_authenticationManagementService.getAuthenticatedUser();
 }
 
-/*
+void Controller::createTechnician(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone)
-Function: 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();
@@ -91,258 +95,120 @@ void Controller::updateUserDetails(const std::string& email, const std::string&
 
 util::Map<std::string, const Service*> Controller::getServices()
 {
-    util::Map<std::string, Service*> currentServices = m_serviceManagementService.getServices();
+    return util::Map<std::string, const Service*>();
-    util::Map<std::string, const Service*> readOnlyServices;
+}
-    for (int iterator = 0; iterator < currentServices.getSize(); iterator++)
+
-    {
+util::Map<std::string, const ComboPackage*> Controller::getComboPackages()
-        readOnlyServices.insert(currentServices.getValueAt(iterator)->getId(), currentServices.getValueAt(iterator));
+{
-    }
+    return util::Map<std::string, const ComboPackage*>();
-    return readOnlyServices;
 }
 
 /*
-Function: getComboPackages
+Function: purchaseService
-Description: Retrieves all available combo packages from the service
+Description: Purchases one or more services for a vehicle by delegating to the service management service.
-             management service and constructs a read-only map.
+Parameter: const util::Vector<std::string>& serviceIDs - IDs of services to purchase
-Parameter: None
+           const std::string& vehicleNumber - vehicle registration number
-Return type: util::Map<std::string, const ComboPackage*>
+           const std::string& vehicleBrand - brand of the vehicle
+           const std::string& vehicleModel - model of the vehicle
+Return type: void
 */
-util::Map<std::string, const ComboPackage*> Controller::getComboPackages()
-{
-    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;
-}
-
 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()
 {
-    auto inventoryIems = m_inventoryManagementService.getInventoryItems();
+    return util::Map<std::string, const InventoryItem*>();
-    util::Map<std::string, const InventoryItem*> readOnlyInventoryItems;
-    int inventoryItemsMapSize = inventoryIems.getSize();
-    for (int index = 0; index < inventoryItemsMapSize; index++)
-    {
-        readOnlyInventoryItems.insert(inventoryIems.getKeyAt(index), inventoryIems.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 m_inventoryManagementService.getInventoryItem(inventoryItemID);
+    return nullptr;
 }
 
-/*
-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);
 }
 
 util::Map<std::string, const ServiceBooking*> Controller::getServiceBookings()
 {
-    auto serviceBookings = m_serviceManagementService.getServiceBookings();
+    return util::Map<std::string, const ServiceBooking*>();
-    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;
 }
 
 util::Map<std::string, const ServiceBooking*> Controller::getServiceBookingsByUser(const std::string userID)
 {
-    util::Map<std::string, const ServiceBooking*> readOnlyServiceBookingsByUserMap;
+    return util::Map<std::string, const ServiceBooking*>();
-    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()
 {
-    auto listOfUsers = m_userManagementService.getUsers();
+    return util::Map<std::string, const User*>();
-    util::Map<std::string, const User*> readOnlyUserList;
-    for (int iterator = 0; iterator < listOfUsers.getSize(); iterator++)
-    {
-        readOnlyUserList.insert(listOfUsers.getKeyAt(iterator), listOfUsers.getValueAt(iterator));
-    }
-    return readOnlyUserList;
 }
 
 util::Map<std::string, const User*> Controller::getUsers(util::UserType userType)
 {
-    auto userMap = m_userManagementService.getUsers(userType);
+    return util::Map<std::string, const User*>();
-    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;
 }
 
 void Controller::createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID)
 {
-    m_serviceManagementService.createJobCard(bookingID, technicianID, serviceID);
 }
 
 void Controller::createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost)
 {
-    m_serviceManagementService.createService(name, inventoryItemIDs, laborCost);
 }
 
 void Controller::removeService(const std::string& serviceID)
 {
-    m_serviceManagementService.removeService(serviceID);
 }
 
 util::Map<std::string, const JobCard*> Controller::getJobCardsByUser()
 {
-    const User* currentUser = getAuthenticatedUser();
+    return util::Map<std::string, const JobCard*>();
-    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;
 }
 
 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_serviceManagementService.cancelCustomerServiceBookings(userID);
-    m_serviceManagementService.cancelTechnicianJobs(userID);
-    m_userManagementService.removeUser(userID);
 }
 
-/*
-Function: createComboPackage
-Description: Creates a new combo package with specified services and discount
-             percentage by delegating to the service management service.
-Parameter: const std::string& name - name of the combo package
-           const util::Vector<std::string>& serviceIDs - list of service IDs
-           double discountPercentage - discount percentage for the package
-Return type: void
-*/
 void Controller::createComboPackage(const std::string& name, const util::Vector<std::string>& serviceIDs, double discountPercentage)
 {
-    m_serviceManagementService.createComboPackage(name, serviceIDs, discountPercentage);
 }
 
-/*
-Function: removeComboPackage
-Description: Removes a combo package by ID by delegating to the service
-             management service.
-Parameter: const std::string& comboPackageID - ID of the combo package
-Return type: void
-*/
 void Controller::removeComboPackage(const std::string& comboPackageID)
 {
-    m_serviceManagementService.removeComboPackage(comboPackageID);
 }
 
 util::Map<std::string, const Invoice*> Controller::getInvoicesByUser()
 {
-    User* currentUser = m_authenticationManagementService.getAuthenticatedUser();
+    return util::Map<std::string, const Invoice*>();
-    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;
 }
 
 void Controller::completePayment(const std::string& invoiceID, util::PaymentMode paymentMode)
 {
-    m_paymentManagementService.completePayment(invoiceID, paymentMode);
 }
 
 /*
@@ -423,6 +289,16 @@ void Controller::configureNotifications(bool paymentNotifications, bool serviceN
     }
 }
 
+/*
+Function: loadSystemData
+Description: Loads all system data from persistent storage into memory.
+             Invokes the respective management services to load users, inventory items, services,
+             combo packages, service bookings, job cards, invoices, and observers.
+Parameters:
+    - None
+Returns:
+    - void
+*/
 void Controller::loadSystemData()
 {
     m_userManagementService.loadUsers();
@@ -437,6 +313,16 @@ void Controller::loadSystemData()
     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();
@@ -453,9 +339,8 @@ void Controller::saveSystemData()
 
 /*
 Function: runSystemChecks
-Description: Executes system checks including sending low stock alerts
+Description: Runs system checks to ensure critical configurations, such as verifying admin existence.
-             and payment reminders.
+Parameter: None
-Parameters: None
 Return type: void
 */
 void Controller::runSystemChecks()

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

@@ -1,8 +1,8 @@
 /*
 File: Controller.h
-Description: Header file declaring the Controller class, which manages
+Description: Header file declaring the Controller class, which coordinates
-             user authentication, inventory, services, bookings, job cards,
+             authentication, user management, service management, inventory,
-             invoices, and notifications in the system.
+             and notifications across the Vehicle Service System.
 Author: Trenser
 Date:19-May-2026
 */
@@ -15,6 +15,10 @@ Date:19-May-2026
 #include "PaymentManagementService.h"
 #include "ServiceManagementService.h"
 #include "UserManagementService.h"
+#include "InventoryManagementService.h"
+#include "UserManagementService.h"
+#include "ServiceManagementService.h"
+#include "PaymentManagementService.h"
 
 class Service;
 class ComboPackage;
@@ -39,7 +43,7 @@ public:
     void changePassword(const std::string& newPassword);
     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& name, const std::string& password, const std::string& email, const std::string& phoneNumber);
+    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();
@@ -48,7 +52,6 @@ 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);

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

@@ -56,6 +56,19 @@ ComboPackage::ComboPackage(const std::string& packageName, double discountPercen
     }
 }
 
+/*
+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),
@@ -212,6 +225,14 @@ 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();
@@ -227,6 +248,14 @@ static std::string getServiceIDsAsString(const util::Vector<std::string>& servic
     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;
@@ -239,6 +268,14 @@ static util::Vector<std::string> getServiceIDsAsVector(const std::string& servic
     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;
@@ -250,6 +287,16 @@ std::string ComboPackage::serialize() const
     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;
@@ -280,6 +327,14 @@ ComboPackage* ComboPackage::deserialize(const std::string& record)
     );
 }
 
+/*
+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/InventoryItem.cpp

@@ -8,9 +8,9 @@ Date: 19-May-2026
 
 #include <sstream>
 #include <stdexcept>
-#include "InventoryItem.h"
 #include "Factory.h"
 #include "StringHelper.h"
+#include "InventoryItem.h"
 
 int InventoryItem::m_uid = 0;
 
@@ -47,6 +47,19 @@ 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),
@@ -191,6 +204,14 @@ 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;
@@ -202,6 +223,16 @@ std::string InventoryItem::serialize() const
     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;
@@ -233,7 +264,15 @@ InventoryItem* InventoryItem::deserialize(const std::string& record)
     );
 }
 
+/*
+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/Invoice.cpp

@@ -58,8 +58,7 @@ Invoice::Invoice(
     const std::string& bookingId,
     ServiceBooking* booking,
     const util::Timestamp& invoiceDate, 
-    double laborCost, 
+    double laborCost, const util::Map<std::string,
-    const util::Map<std::string,
     InventoryItem*>& parts,
     double partsCost,
     double discountPercentage, 
@@ -122,6 +121,12 @@ Invoice::Invoice(
     }
 }
 
+/*
+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;
@@ -171,6 +176,14 @@ double Invoice::getLaborCost() const
     return m_laborCost;
 }
 
+/*
+Function: getPartIDs
+Description: Retrieves the IDs of parts used in the invoice.
+Parameters:
+    - None
+Returns:
+    - const util::Vector<std::string>&: Part IDs
+*/
 const util::Vector<std::string>& Invoice::getPartIDs() const
 {
     return m_partIDs;
@@ -180,7 +193,7 @@ const util::Vector<std::string>& Invoice::getPartIDs() const
 Function: getParts
 Description: Retrieves the map of inventory items used in the service.
 Returns:
-    - const util::Map<std::string, InventoryItem*>& representing the parts.
+    - const util::Map<int, InventoryItem*>& representing the parts.
 */
 const util::Map<std::string, InventoryItem*>& Invoice::getParts() const
 {
@@ -416,6 +429,14 @@ 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();
@@ -431,6 +452,14 @@ static std::string getPartIDsAsString(const util::Vector<std::string>& partIDs)
     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;
@@ -443,6 +472,14 @@ static util::Vector<std::string> getPartIDsAsVector(const std::string& partIDsSt
     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;
@@ -460,6 +497,16 @@ std::string Invoice::serialize() const
     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;
@@ -512,7 +559,15 @@ Invoice* Invoice::deserialize(const std::string& record)
     );
 }
 
+/*
+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

@@ -40,8 +40,8 @@ public:
         const std::string& bookingId,
         ServiceBooking* booking,
         const util::Timestamp& invoiceDate, 
-        double laborCost, 
+        double laborCost, const util::Map<std::string,
-        const util::Map<std::string,InventoryItem*>& parts,
+        InventoryItem*>& parts,
         double partsCost,
         double discountPercentage, 
         double totalAmount, 

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

@@ -1,11 +1,12 @@
 /*
 File: JobCard.cpp
-Description: Implementation file containing the method definitions of the
+Description: Implements the JobCard class which represents a technician’s job assignment in the Vehicle Service Management System.
-             JobCard class, including constructors, getters, and setters
+             Provides constructors, accessors, and mutators for job details such as ID, booking, service, technician,
-             for job card attributes.
+             assigned date, completion date, and job status.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
+
 #include <sstream>
 #include <stdexcept>
 #include "JobCard.h"
@@ -33,18 +34,19 @@ JobCard::JobCard()
 
 /*
 Function: JobCard
-Description: Parameterized constructor that initializes a job card with
+Description: Parameterized constructor that initializes a new job card with a unique ID and specified details.
-             booking, service, technician, and status details.
+Parameters:
-Parameter: const std::string& bookingId - ID of the booking
+    - bookingId: ID of the associated service booking.
-           ServiceBooking* booking - pointer to the booking object
+    - booking: Pointer to the ServiceBooking object.
-           Service* service - pointer to the service object
+    - service: Pointer to the Service object.
-           const std::string& serviceId - ID of the service
+    - serviceId: ID of the associated service.
-           const std::string& technicianId - ID of the technician
+    - technicianId: ID of the assigned technician.
-           User* technician - pointer to the technician object
+    - technician: Pointer to the User object representing the technician.
-           const util::Timestamp& assignedDate - date when job was assigned
+    - assignedDate: Timestamp of when the job was assigned.
-           util::ServiceJobStatus status - current status of the job
+    - status: Current status of the job (STARTED/COMPLETED).
-           const util::Timestamp& completionDate - date when job was completed
+    - completionDate: Timestamp of when the job was completed.
-Return type: Constructor
+Returns:
+    - A new JobCard object.
 */
 JobCard::JobCard(const std::string& bookingId,
     ServiceBooking* booking,
@@ -67,6 +69,22 @@ 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,
@@ -183,9 +201,9 @@ const util::Timestamp& JobCard::getAssignedDate() const
 
 /*
 Function: getStatus
-Description: Retrieves the current status of the job card.
+Description: Retrieves the current status of the job.
-Parameter: None
+Returns:
-Return type: util::ServiceJobStatus
+    - ServiceJobStatus representing the job status.
 */
 util::ServiceJobStatus JobCard::getStatus() const
 {
@@ -309,9 +327,11 @@ void JobCard::setAssignedDate(const util::Timestamp& assignedDate)
 
 /*
 Function: setStatus
-Description: Sets the status of the job card.
+Description: Sets the current status of the job.
-Parameter: util::ServiceJobStatus status - new job status
+Parameters:
-Return type: void
+    - status: New job status value.
+Returns:
+    - void
 */
 void JobCard::setStatus(util::ServiceJobStatus status)
 {
@@ -331,6 +351,14 @@ 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;
@@ -344,6 +372,16 @@ std::string JobCard::serialize() const
     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;
@@ -379,6 +417,14 @@ JobCard* JobCard::deserialize(const std::string& record)
     );
 }
 
+/*
+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,14 +1,13 @@
 /*
 File: JobCard.h
-Description: Header file declaring the JobCard class, which represents
+Description: Declares the JobCard class which represents a technician’s job assignment in the Vehicle Service Management System.
-             a service job card containing booking, service, technician,
+             Each job card includes booking details, associated service, technician information, assigned and completion dates, and job status.
-             and status details.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
+
 #pragma once
 #include <string>
-#include "Enums.h"
 #include "Timestamp.h"
 #include "Enums.h"
 
@@ -30,6 +29,7 @@ private:
     util::Timestamp m_assignedDate;
     util::ServiceJobStatus m_status;
     util::Timestamp m_completionDate;
+
 public:
     JobCard();
     JobCard(const std::string& bookingId,

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

@@ -45,6 +45,19 @@ 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),
@@ -204,6 +217,14 @@ 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;
@@ -215,6 +236,16 @@ std::string Notification::serialize() const
     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;
@@ -242,6 +273,14 @@ Notification* Notification::deserialize(const std::string& record)
     );
 }
 
+/*
+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/Service.cpp

@@ -54,6 +54,19 @@ Service::Service(const std::string& name, const util::Map<std::string, Inventory
     }
 }
 
+/*
+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),
@@ -90,6 +103,14 @@ 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;
@@ -200,6 +221,14 @@ 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();
@@ -215,6 +244,14 @@ static std::string getInventoryItemIDsAsString(const util::Vector<std::string>&
     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;
@@ -227,6 +264,14 @@ static util::Vector<std::string> getInventoryItemIDsAsVector(const std::string&
     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;
@@ -238,6 +283,16 @@ std::string Service::serialize() const
     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;
@@ -268,6 +323,14 @@ Service* Service::deserialize(const std::string& record)
     );
 }
 
+/*
+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/ServiceBooking.cpp

@@ -20,10 +20,8 @@ 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:
+Parameters: None
-    - None
+Returns: A new ServiceBooking object.
-Returns:
-    - A new ServiceBooking object.
 */
 ServiceBooking::ServiceBooking()
     : m_id("SRV" + std::to_string(++m_uid)),
@@ -33,18 +31,21 @@ ServiceBooking::ServiceBooking()
 
 /*
 Function: ServiceBooking
-Description: Parameterized constructor that initializes a service booking
+Description: Parameterized constructor that initializes a new service booking with a unique ID and specified details.
-             with customer, vehicle, technician, and discount details.
+Parameters:
-Parameter: const std::string& id - booking ID
+    - id: Booking ID string.
-           util::ServiceJobStatus status - current booking status
+    - status: Current status of the booking (e.g., PENDING, COMPLETED).
-           const util::Map<std::string, Service*>& services - map of services
+    - services: Map of services included in the booking.
-           const std::string& customerId - ID of the customer
+    - customerId: ID of the customer.
-           User* customer - pointer to the customer object
+    - customer: Pointer to the User object representing the customer.
-           const std::string& vehicleNumber - vehicle registration number
+    - vehicleNumber: Vehicle registration number.
-           const std::string& vehicleBrand - brand of the vehicle
+    - vehicleBrand: Brand of the vehicle.
-           const std::string& vehicleModel - model of the vehicle
+    - vehicleModel: Model of the vehicle.
-           double discountPercentage - discount applied to the booking
+    - assignedTechnicianId: ID of the assigned technician.
-Return type: Constructor
+    - assignedTechnician: Name of the assigned technician.
+    - discountPercentage: Discount applied to the booking.
+Returns:
+    - A new ServiceBooking object.
 */
 ServiceBooking::ServiceBooking(
     util::ServiceJobStatus status,
@@ -77,6 +78,24 @@ ServiceBooking::ServiceBooking(
     }
 }
 
+/*
+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,
@@ -107,6 +126,12 @@ ServiceBooking::ServiceBooking(
     }
 }
 
+/*
+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;
@@ -115,14 +140,22 @@ const std::string& ServiceBooking::getId() const
 /*
 Function: getStatus
 Description: Retrieves the current status of the service booking.
-Returns:
+Parameter: None
-    - util::ServiceJobStatus representing the booking status.
+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;
@@ -130,9 +163,9 @@ const util::Vector<std::string>& ServiceBooking::getServiceIDs() const
 
 /*
 Function: getServices
-Description: Retrieves the map of services included in the booking.
+Description: Retrieves the services associated with the booking.
-Returns:
+Parameter: None
-    - const util::Map<std::string, Service*>& representing the services.
+Return type: const util::Map<std::string, Service*>&
 */
 const util::Map<std::string, Service*>& ServiceBooking::getServices() const
 {
@@ -142,8 +175,8 @@ const util::Map<std::string, Service*>& ServiceBooking::getServices() const
 /*
 Function: getCustomerId
 Description: Retrieves the customer ID associated with the booking.
-Returns:
+Parameter: None
-    - const std::string& representing the customer ID.
+Return type: const std::string&
 */
 const std::string& ServiceBooking::getCustomerId() const
 {
@@ -152,9 +185,9 @@ const std::string& ServiceBooking::getCustomerId() const
 
 /*
 Function: getCustomer
-Description: Retrieves the pointer to the associated customer.
+Description: Retrieves the customer object associated with the booking.
-Returns:
+Parameter: None
-    - User* representing the customer.
+Return type: User*
 */
 User* ServiceBooking::getCustomer() const
 {
@@ -163,9 +196,9 @@ User* ServiceBooking::getCustomer() const
 
 /*
 Function: getVehicleNumber
-Description: Retrieves the vehicle registration number.
+Description: Retrieves the vehicle registration number for the booking.
-Returns:
+Parameter: None
-    - const std::string& representing the vehicle number.
+Return type: const std::string&
 */
 const std::string& ServiceBooking::getVehicleNumber() const
 {
@@ -174,9 +207,9 @@ const std::string& ServiceBooking::getVehicleNumber() const
 
 /*
 Function: getVehicleBrand
-Description: Retrieves the brand of the vehicle.
+Description: Retrieves the brand of the vehicle for the booking.
-Returns:
+Parameter: None
-    - const std::string& representing the vehicle brand.
+Return type: const std::string&
 */
 const std::string& ServiceBooking::getVehicleBrand() const
 {
@@ -185,9 +218,9 @@ const std::string& ServiceBooking::getVehicleBrand() const
 
 /*
 Function: getVehicleModel
-Description: Retrieves the model of the vehicle.
+Description: Retrieves the model of the vehicle for the booking.
-Returns:
+Parameter: None
-    - const std::string& representing the vehicle model.
+Return type: const std::string&
 */
 const std::string& ServiceBooking::getVehicleModel() const
 {
@@ -196,9 +229,9 @@ const std::string& ServiceBooking::getVehicleModel() const
 
 /*
 Function: getAssignedTechnicianId
-Description: Retrieves the ID of the assigned technician.
+Description: Retrieves the ID of the technician assigned to the booking.
-Returns:
+Parameter: None
-    - const std::string& representing the technician ID.
+Return type: const std::string&
 */
 const std::string& ServiceBooking::getAssignedTechnicianId() const
 {
@@ -215,12 +248,11 @@ User* ServiceBooking::getAssignedTechnician() const
 {
     return m_assignedTechnician;
 }
-
 /*
 Function: getDiscountPercentage
 Description: Retrieves the discount percentage applied to the booking.
-Returns:
+Parameter: None
-    - double representing the discount percentage.
+Return type: double
 */
 double ServiceBooking::getDiscountPercentage() const
 {
@@ -229,11 +261,9 @@ double ServiceBooking::getDiscountPercentage() const
 
 /*
 Function: setId
-Description: Sets the unique ID of the service booking.
+Description: Sets the unique identifier of the service booking.
-Parameters:
+Parameter: const std::string& id - new booking ID
-    - id: New booking ID string.
+Return type: void
-Returns:
-    - void
 */
 void ServiceBooking::setId(const std::string& id)
 {
@@ -243,10 +273,8 @@ void ServiceBooking::setId(const std::string& id)
 /*
 Function: setStatus
 Description: Sets the current status of the service booking.
-Parameters:
+Parameter: const util::ServiceJobStatus& status - new booking status
-    - status: New booking status value.
+Return type: void
-Returns:
-    - void
 */
 void ServiceBooking::setStatus(const util::ServiceJobStatus& status)
 {
@@ -255,11 +283,9 @@ void ServiceBooking::setStatus(const util::ServiceJobStatus& status)
 
 /*
 Function: setServices
-Description: Sets the services included in the booking.
+Description: Sets the services associated with the booking.
-Parameters:
+Parameter: const util::Map<std::string, Service*>& services - new services map
-    - services: Map of services.
+Return type: void
-Returns:
-    - void
 */
 void ServiceBooking::setServices(const util::Map<std::string, Service*>& services)
 {
@@ -275,11 +301,9 @@ void ServiceBooking::setServices(const util::Map<std::string, Service*>& service
 
 /*
 Function: setCustomerId
-Description: Sets the customer ID associated with the booking.
+Description: Sets the customer ID for the booking.
-Parameters:
+Parameter: const std::string& customerId - new customer ID
-    - customerId: New customer ID string.
+Return type: void
-Returns:
-    - void
 */
 void ServiceBooking::setCustomerId(const std::string& customerId)
 {
@@ -288,11 +312,9 @@ void ServiceBooking::setCustomerId(const std::string& customerId)
 
 /*
 Function: setCustomer
-Description: Sets the pointer to the associated customer.
+Description: Sets the customer object for the booking.
-Parameters:
+Parameter: User* customer - pointer to the customer object
-    - customer: Pointer to the User object.
+Return type: void
-Returns:
-    - void
 */
 void ServiceBooking::setCustomer(User* customer)
 {
@@ -301,11 +323,9 @@ void ServiceBooking::setCustomer(User* customer)
 
 /*
 Function: setVehicleNumber
-Description: Sets the vehicle registration number.
+Description: Sets the vehicle registration number for the booking.
-Parameters:
+Parameter: const std::string& vehicleNumber - new vehicle number
-    - vehicleNumber: New vehicle number string.
+Return type: void
-Returns:
-    - void
 */
 void ServiceBooking::setVehicleNumber(const std::string& vehicleNumber)
 {
@@ -314,11 +334,9 @@ void ServiceBooking::setVehicleNumber(const std::string& vehicleNumber)
 
 /*
 Function: setVehicleBrand
-Description: Sets the brand of the vehicle.
+Description: Sets the brand of the vehicle for the booking.
-Parameters:
+Parameter: const std::string& vehicleBrand - new vehicle brand
-    - vehicleBrand: New vehicle brand string.
+Return type: void
-Returns:
-    - void
 */
 void ServiceBooking::setVehicleBrand(const std::string& vehicleBrand)
 {
@@ -327,11 +345,9 @@ void ServiceBooking::setVehicleBrand(const std::string& vehicleBrand)
 
 /*
 Function: setVehicleModel
-Description: Sets the model of the vehicle.
+Description: Sets the model of the vehicle for the booking.
-Parameters:
+Parameter: const std::string& vehicleModel - new vehicle model
-    - vehicleModel: New vehicle model string.
+Return type: void
-Returns:
-    - void
 */
 void ServiceBooking::setVehicleModel(const std::string& vehicleModel)
 {
@@ -340,11 +356,9 @@ void ServiceBooking::setVehicleModel(const std::string& vehicleModel)
 
 /*
 Function: setAssignedTechnicianId
-Description: Sets the ID of the assigned technician.
+Description: Sets the ID of the technician assigned to the booking.
-Parameters:
+Parameter: const std::string& assignedTechnicianId - new technician ID
-    - assignedTechnicianId: New technician ID string.
+Return type: void
-Returns:
-    - void
 */
 void ServiceBooking::setAssignedTechnicianId(const std::string& assignedTechnicianId)
 {
@@ -364,17 +378,23 @@ void ServiceBooking::setAssignedTechnician(User* assignedTechnician)
 
 /*
 Function: setDiscountPercentage
-Description: Sets the discount percentage applied to the booking.
+Description: Sets the discount percentage for the booking.
-Parameters:
+Parameter: double discountPercentage - new discount percentage
-    - discountPercentage: New discount percentage value.
+Return type: void
-Returns:
-    - 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();
@@ -390,6 +410,14 @@ static std::string getServiceIDsAsString(const util::Vector<std::string>& servic
     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;
@@ -402,6 +430,14 @@ static util::Vector<std::string> getServiceIDsAsVector(const std::string& servic
     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;
@@ -417,6 +453,16 @@ std::string ServiceBooking::serialize() const
     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;
@@ -455,7 +501,15 @@ ServiceBooking* ServiceBooking::deserialize(const std::string& record)
     );
 }
 
+/*
+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/User.cpp

@@ -53,6 +53,22 @@ User::User(const std::string& userName, const std::string& password, const std::
     m_type(role),
     m_status(util::State::ACTIVE) {}
 
+/*
+Function: User (parameterized constructor with ID)
+Description: Initializes a user with an existing ID, credentials, personal details,
+             role, and state. Updates UID tracking based on ID.
+Parameters:
+    - userId: const std::string&, unique user ID
+    - userName: const std::string&, username
+    - password: const std::string&, password
+    - name: const std::string&, full name
+    - phone: const std::string&, phone number
+    - email: const std::string&, email address
+    - role: util::UserType, role of the user
+    - status: util::State, state of the user (ACTIVE/INACTIVE)
+Returns:
+    - A new User object
+*/
 User::User(const std::string& userId, const std::string& userName, const std::string& password, const std::string& name, const std::string& phone, const std::string& email, util::UserType role, util::State status)
     : m_id(userId),
     m_userName(userName),
@@ -306,6 +322,14 @@ void User::setState(util::State status)
     m_status = status;
 }
 
+/*
+Function: serialize
+Description: Serializes the user into a CSV-formatted string.
+Parameters:
+    - None
+Returns:
+    - std::string: Serialized user record
+*/
 std::string User::serialize() const
 {
     std::ostringstream serializedUser;
@@ -320,6 +344,14 @@ std::string User::serialize() const
     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;
@@ -345,8 +377,15 @@ User* User::deserialize(const std::string& record)
         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/services/AuthenticationManagementService.cpp

@@ -1,8 +1,8 @@
 /*
 File: AuthenticationManagementService.cpp
 Description: Implementation file containing the method definitions of the
-			 AuthenticationManagementService class, including logout and
+			 AuthenticationManagementService class, including login, logout,
-			 password change logic.
+			 password change, and retrieval of the authenticated user.
 Author: Trenser
 Date:19-May-2026
 */
@@ -12,6 +12,15 @@ Date:19-May-2026
 
 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();
@@ -32,6 +41,12 @@ bool AuthenticationManagementService::login(const std::string& username, const s
 	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;

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

@@ -1,107 +1,35 @@
 /*
 File: InventoryManagementService.cpp
-Description: Implementation file containing the method definitions of the
+Description: Implements the InventoryManagementService class, which manages inventory
-             InventoryManagementService class, including inventory operations
+			 items and observer relationships within the system. Provides methods
-             and notification handling.
+			 for loading and saving inventory items from persistent storage, as well
+			 as attaching and persisting observers for notification handling.
 Author: Trenser
-Date:19-May-2026
+Date: 22-May-2026
 */
-#include "InventoryManagementService.h"
+
+#include <stdexcept>
 #include "Config.h"
-#include "Vector.h"
 #include "Enums.h"
-#include "InventoryItem.h"
-#include "Config.h"
-#include "User.h"
 #include "Factory.h"
-#include "Timestamp.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: addInventoryItem
+Function: attach
-Description: Creates a new inventory item using the Factory and inserts it
+Description: Adds a user to the observer list for receiving inventory notifications.
-			 into the DataStore.
+Parameters:
-Parameter: const std::string& partName - name of the part
+	- user: User*, pointer to the user to be attached as an observer
-		   int quantity - initial quantity of the part
+Returns:
-		   double price - price of the part
+	- None
-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;
-}
-
 void InventoryManagementService::attach(User* user)
 {
 	if (user)
@@ -114,6 +42,14 @@ void InventoryManagementService::attach(User* user)
 	}
 }
 
+/*
+Function: detach
+Description: Removes a user from the observer list so they no longer receive inventory notifications.
+Parameters:
+	- user: User*, pointer to the user to be detached from the observer list
+Returns:
+	- None
+*/
 void InventoryManagementService::detach(User* user)
 {
 	if (user)
@@ -126,6 +62,18 @@ void InventoryManagementService::detach(User* user)
 	}
 }
 
+/*
+Function: sendNotification
+Description: Sends a notification to a user if they are subscribed as an observer.
+Parameters:
+	- user: User*, pointer to the user receiving the notification
+	- title: std::string, title of the notification
+	- message: std::string, body/content of the notification
+Returns:
+	- None
+Throws:
+	- std::runtime_error if notification creation fails
+*/
 void InventoryManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
 {
 	if (user)
@@ -152,27 +100,42 @@ void InventoryManagementService::sendNotification(User* user, const std::string&
 	}
 }
 
+/*
+Function: sendLowStockAlertsToAdmins (static helper)
+Description: Sends low stock alert notifications to all admin users for a given inventory item.
+Parameters:
+	- inventoryManagementService: InventoryManagementService&, service used to send notifications
+	- inventoryItem: const InventoryItem*, pointer to the low-stock inventory item
+	- adminUsers: const util::Vector<User*>&, list of admin users to notify
+Returns:
+	- None
+*/
 static void sendLowStockAlertsToAdmins(InventoryManagementService& inventoryManagementService, const InventoryItem* inventoryItem, const util::Vector<User*>& adminUsers)
 {
 	int adminUsersSize = adminUsers.getSize();
 	for (int index = 0; index < adminUsersSize; index++)
 	{
+		std::string title = "Low Stock Alert";
+		std::string message = "The inventory item with ID " + inventoryItem->getId() + " has very low quantity in the inventory";
 		inventoryManagementService.sendNotification(
 			adminUsers[index],
-			"Low Stock Alert",
+			title,
-			"The inventory item with ID " + inventoryItem->getId() +
+			message
-			" has very low quantity in the inventory"
+		);
-			);
 	}
 }
 
+/*
+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();
@@ -200,6 +163,15 @@ void InventoryManagementService::sendLowStockAlerts()
 	}
 }
 
+/*
+Function: getObserverIDs
+Description: Retrieves the IDs of all observers currently attached to the
+			 InventoryManagementService.
+Parameters:
+	- None
+Returns:
+	- util::Vector<std::string>: Vector of observer user IDs
+*/
 util::Vector<std::string> InventoryManagementService::getObserverIDs()
 {
 	util::Vector<std::string> observerIDs;
@@ -215,6 +187,15 @@ util::Vector<std::string> InventoryManagementService::getObserverIDs()
 	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);
@@ -227,6 +208,15 @@ void InventoryManagementService::loadInventoryItems()
 	}
 }
 
+/*
+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);
@@ -234,12 +224,30 @@ void InventoryManagementService::saveInventoryItems()
 	inventoryItemFileManager.save(inventoryItems);
 }
 
+/*
+Function: loadObservers
+Description: Loads observer IDs from persistent storage and attaches corresponding
+			 users as observers to the InventoryManagementService.
+Parameters:
+	- None
+Returns:
+	- void
+*/
 void InventoryManagementService::loadObservers()
 {
 	util::loadObservers(config::file::INVENTORYMANAGEMENTOBSERVERS, this, m_dataStore);
 }
 
+/*
+Function: saveObservers
+Description: Saves the current observer IDs of the InventoryManagementService
+			 to persistent storage for future retrieval.
+Parameters:
+	- None
+Returns:
+	- void
+*/
 void InventoryManagementService::saveObservers()
 {
 	util::saveObservers(config::file::INVENTORYMANAGEMENTOBSERVERS, this);
-}
+}

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

@@ -1,11 +1,11 @@
 /*
 File: InventoryManagementService.h
-Description: Header file declaring the InventoryManagementService class,
+Description: Declares the InventoryManagementService class which manages inventory operations in the Vehicle Service Management System.
-             which manages inventory items, stock updates, and notifications
+             Provides functionality to retrieve, add, and remove inventory items, send low stock alerts, and handle notifications using the Observer pattern.
-             related to low stock alerts. Inherits from NotificationManagementService.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
+
 #pragma once
 #include <string>
 #include "Map.h"
@@ -27,7 +27,6 @@ public:
     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;

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

@@ -8,15 +8,12 @@ Date: 20-May-2026
 */
 
 #include <stdexcept>
-#include "PaymentManagementService.h"
 #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"
@@ -24,90 +21,6 @@ Date: 20-May-2026
 
 util::Map<std::string, User*> PaymentManagementService::m_observers{};
 
-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);
-	}
-}
-
-void PaymentManagementService::generateInvoice(ServiceBooking* booking)
-{
-	if (!booking)
-	{
-		throw std::runtime_error("Invoice generation failed: booking is null.");
-	}
-	double totalLabourCost = 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);
-		if (currentJobCard->getBookingId() == bookingID && currentJobCard->getStatus() != 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);
-			totalLabourCost += currentService->getLaborCost();
-			totalPartsCost += util::calculatePartsCost(currentService);
-		}
-	}
-	totalServiceCost = totalLabourCost + totalPartsCost;
-	totalServiceCost -= (totalServiceCost * (discountPercentage / 100));
-	Invoice* invoice = Factory::getObject<Invoice>(bookingID, booking, util::Timestamp(), totalLabourCost, 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);
-}
-
-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;
-}
-
-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);
-		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.");
-	}
-}
-
 /*
 Function: attach
 Description: Attaches a user as an observer to the PaymentManagementService for receiving notifications.
@@ -214,9 +127,9 @@ void PaymentManagementService::sendPaymentReminders()
 					User* customer = serviceBooking->getCustomer();
 					if (customer)
 					{
-						sendNotification(customer,
+						std::string title = "Payment Reminder";
-							"Payment Reminder",
+						std::string message = "Your payment for Invoice ID " + invoice->getId() + " is still pending. Please complete the payment.";
-							"Your payment for Invoice ID " + invoice->getId() + " is still pending.Please complete the payment." + invoice->getId());
+						sendNotification(customer, title, message);
 					}
 				}
 			}
@@ -224,6 +137,15 @@ void PaymentManagementService::sendPaymentReminders()
 	}
 }
 
+/*
+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;
@@ -239,6 +161,19 @@ util::Vector<std::string> PaymentManagementService::getObserverIDs()
 	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);
@@ -272,6 +207,16 @@ void PaymentManagementService::loadInvoices()
         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);
@@ -279,12 +224,32 @@ void PaymentManagementService::saveInvoices()
     invoiceFileManager.save(invoices);
 }
 
+/*
+Function: loadObservers
+Description: Loads observer IDs from persistent storage and attaches corresponding
+             users as observers to the PaymentManagementService.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if an observer ID is invalid (not found in datastore)
+*/
 void PaymentManagementService::loadObservers()
 {
     util::loadObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this, m_dataStore);
 }
 
+/*
+Function: saveObservers
+Description: Saves the current observer IDs of the PaymentManagementService
+             to persistent storage for future retrieval.
+Parameters:
+    - None
+Returns:
+    - void
+*/
 void PaymentManagementService::saveObservers()
 {
     util::saveObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this);
-}
+}

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

@@ -1,8 +1,8 @@
 /*
 File: ServiceManagementService.cpp
 Description: Implementation file containing the method definitions of the
-             ServiceManagementService class, including service booking cancellation,
+			 ServiceManagementService class, including service and combo package
-             job card management, combo package creation, and removal logic.
+			 purchasing logic, booking creation, and notification handling.
 Author: Trenser
 Date:19-May-2026
 */
@@ -11,237 +11,27 @@ Date:19-May-2026
 #include "AuthenticationManagementService.h"
 #include "ComboPackage.h"
 #include "Config.h"
-#include "Enums.h"
 #include "Factory.h"
 #include "FileManager.h"
-#include "InventoryItem.h"
-#include "Invoice.h"
 #include "JobCard.h"
-#include "NotificationManagementService.h"
-#include "PaymentManagementService.h"
 #include "Service.h"
 #include "ServiceBooking.h"
 #include "ServiceManagementService.h"
 #include "Timestamp.h"
 #include "User.h"
-#include "UserManagementService.h"
 #include "Utility.h"
 
-util::Map<std::string, User*> ServiceManagementService::m_observers{};
+/*
-
+Function: purchaseService
-util::Map<std::string, ServiceBooking*> ServiceManagementService::getServiceBookings()
+Description: Creates a new service booking for the authenticated user. Validates
-{
+			 service IDs, retrieves services from the DataStore, and generates a
-	return m_dataStore.getServiceBookings();
+			 booking. Sends a notification upon successful booking.
-}
+Parameter: const util::Vector<std::string>& serviceIDs - IDs of services to purchase
-
+		   const std::string& vehicleNumber - vehicle registration number
-ServiceBooking* ServiceManagementService::getServiceBooking(const std::string& serviceID)
+		   const std::string& vehicleBrand - brand of the vehicle
-{
+		   const std::string& vehicleModel - model of the vehicle
-	auto currentServiceBookings = getServiceBookings();
+Return type: void
-	for (int iterator = 0; iterator < currentServiceBookings.getSize(); iterator++)
+*/
-	{
-		if (currentServiceBookings.getValueAt(iterator)->getId() == serviceID)
-		{
-			return currentServiceBookings.getValueAt(iterator);
-		}
-	}
-	return nullptr;
-}
-
-void ServiceManagementService::createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID)
-{
-	UserManagementService m_userManagementService;
-	ServiceBooking* currentBooking = getServiceBooking(bookingID);
-	auto& currentJobCards = m_dataStore.getJobCards();
-	if (currentBooking == nullptr)
-	{
-		throw std::runtime_error("Service Booking not available");
-	}
-	auto& currentServices = currentBooking->getServices();
-	if (currentServices.find(serviceID) == -1)
-	{
-		throw std::runtime_error("Invalid service Id");
-	}
-	Service* currentService = currentServices.getValueAt(currentServices.find(serviceID));
-	User* selectedTechnician = m_userManagementService.getUser(technicianID);
-	if (selectedTechnician == nullptr)
-	{
-		throw std::runtime_error("Technician not available");
-	}
-	auto& inventoryItems = currentService->getRequiredInventoryItems();
-	for (int iterator = 0; iterator < inventoryItems.getSize(); iterator++)
-	{
-		InventoryItem* currentInventoryItem = inventoryItems.getValueAt(iterator);
-		if (currentInventoryItem->getQuantity() == 0)
-		{
-			std::string errorMessage = "Failed to create job card, " + currentInventoryItem->getPartName() + " is out of stock.";
-			throw std::runtime_error(errorMessage);
-		}
-		else
-		{
-			int currentStockQuantity = currentInventoryItem->getQuantity();
-			currentInventoryItem->setQuantity(currentStockQuantity - 1);
-		}
-	}
-	currentBooking->setAssignedTechnician(selectedTechnician);
-	currentBooking->setAssignedTechnicianId(selectedTechnician->getId());
-	std::string title = "Job card created";
-	std::string message = "Job card created for the service and you are assigned for that.";
-	JobCard* jobCard = Factory::getObject<JobCard>(bookingID, currentBooking, currentService, serviceID, technicianID, selectedTechnician, util::Timestamp(), util::ServiceJobStatus::STARTED, util::Timestamp());
-	currentJobCards.insert(jobCard->getId(), jobCard);
-	sendNotification(selectedTechnician, title, message);
-}
-
-void ServiceManagementService::createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost)
-{
-	util::Map<std::string, InventoryItem*> currentServiceInventoryItems;
-	auto inventoryItems = m_dataStore.getInventoryItems();
-	for (int iteratorOne = 0; iteratorOne < inventoryItemIDs.getSize(); iteratorOne++)
-	{
-		std::string currentItemID = inventoryItemIDs[iteratorOne];
-		bool itemFound = false;
-		for (int iteratorTwo = 0; iteratorTwo < inventoryItems.getSize(); iteratorTwo++)
-		{
-			InventoryItem* currentInventoryItem = inventoryItems.getValueAt(iteratorTwo);
-			if (currentInventoryItem && currentInventoryItem->getId() == currentItemID)
-			{
-				itemFound = true;
-				currentServiceInventoryItems.insert(currentInventoryItem->getId(), currentInventoryItem);
-				break;
-			}
-		}
-		if (!itemFound)
-		{
-			throw std::runtime_error("Inventory item with ID '" + currentItemID + "' not found.");
-		}
-	}
-	Service* newService = Factory::getObject<Service>(name, currentServiceInventoryItems, laborCost);
-	if (newService == nullptr)
-	{
-		throw std::runtime_error("Unable to create new service.");
-	}
-	util::Map<std::string, Service*>& currentServices = m_dataStore.getServices();
-	if (currentServices.find(newService->getId()) != -1)
-	{
-		throw std::runtime_error("Service with this ID Already exists.");
-	}
-	currentServices.insert(newService->getId(), newService);
-}
-
-util::Map<std::string, Service*> ServiceManagementService::getServices()
-{
-	return m_dataStore.getServices();
-}
-
-void ServiceManagementService::removeService(const std::string& serviceID)
-{
-	util::Map<std::string, Service*> currentServices = getServices();
-	if (currentServices.find(serviceID) != -1)
-	{
-		currentServices.getValueAt(currentServices.find(serviceID))->setState(util::State::INACTIVE);
-	}
-	else
-	{
-		throw std::runtime_error("Service not found.");
-	}
-}
-
-util::Map<std::string, ServiceBooking*> ServiceManagementService::getServiceBookings(const std::string& customerID)
-{
-	util::Map<std::string, ServiceBooking*> currentServiceBookings = getServiceBookings();
-	util::Map<std::string, ServiceBooking*> currentUserServiceBookings;
-	if (currentServiceBookings.getSize() != 0)
-	{
-		for (int iterator = 0; iterator < currentServiceBookings.getSize(); iterator++)
-		{
-			auto currentServiceBooking = currentServiceBookings.getValueAt(iterator);
-			if (currentServiceBooking->getCustomerId() == customerID)
-			{
-				currentUserServiceBookings.insert(currentServiceBooking->getId(), currentServiceBooking);
-			}
-		}
-	}
-	return currentUserServiceBookings;
-}
-
-util::Map<std::string, JobCard*> ServiceManagementService::getJobCards(const std::string& technicianID)
-{
-	util::Map<std::string, JobCard*> jobCards = m_dataStore.getJobCards();
-	util::Map<std::string, JobCard*> technicianJobCards;
-	for (int iterator = 0; iterator < jobCards.getSize(); iterator++)
-	{
-		JobCard* currentJobCard = jobCards.getValueAt(iterator);
-		if (currentJobCard->getTechnicianId() == technicianID)
-		{
-			technicianJobCards.insert(currentJobCard->getId(), currentJobCard);
-		}
-	}
-	return technicianJobCards;
-}
-
-static bool hasAllJobCardsinServiceBookingCompleted(std::string bookingId, util::Map<std::string, JobCard*>& currentAssignedJobs)
-{
-	for (int iterator = 0; iterator < currentAssignedJobs.getSize(); iterator++)
-	{
-		JobCard* currentJob = currentAssignedJobs.getValueAt(iterator);
-		if (currentJob->getBookingId() == bookingId)
-		{
-			if (currentJob->getStatus() == util::ServiceJobStatus::STARTED)
-			{
-				return false;
-			}
-		}
-	}
-	return true;
-}
-
-void ServiceManagementService::completeJob(const std::string& jobID)
-{
-	AuthenticationManagementService authenticationManagementService;
-	PaymentManagementService paymentManagementService;
-	bool jobStatusUpdated = false, serviceBookingCompleted;
-	JobCard* currentJob;
-	User* currentTechnician = authenticationManagementService.getAuthenticatedUser();
-	if (currentTechnician == nullptr)
-	{
-		throw std::runtime_error("Unable to fetch current technician.");
-	}
-	util::Map<std::string, JobCard*> currentAssignedJobs = getJobCards(currentTechnician->getId());
-	if (currentAssignedJobs.getSize() == 0)
-	{
-		throw std::runtime_error("No job cards assigned to the technician.");
-	}
-	if (currentAssignedJobs.find(jobID) != -1)
-	{
-		currentJob = currentAssignedJobs.getValueAt(currentAssignedJobs.find(jobID));
-		if (currentJob == nullptr)
-		{
-			throw std::runtime_error("Unable to fetch current job.");
-		}
-		if (currentJob->getStatus() == util::ServiceJobStatus::STARTED)
-		{
-			currentJob->setStatus(util::ServiceJobStatus::COMPLETED);
-			jobStatusUpdated = true;
-		}
-	}
-	else
-	{
-		throw std::runtime_error("Failed to complete the job, some error occured or job already completed.");
-	}
-	if (!jobStatusUpdated)
-	{
-		throw std::runtime_error("Failed to complete the job, some error occured or job already completed.");
-	}
-	serviceBookingCompleted = hasAllJobCardsinServiceBookingCompleted(currentJob->getBookingId(), currentAssignedJobs);
-	if (serviceBookingCompleted)
-	{
-		currentJob->getBooking()->setStatus(util::ServiceJobStatus::COMPLETED);
-		paymentManagementService.generateInvoice(currentJob->getBooking());
-		std::string title = "Service Booking completed,Invoice Generated.\n";
-		std::string message = "Services completed for the booking and invoice generated.\n";
-		sendNotification(currentJob->getBooking()->getCustomer(), title, message);
-	}
-}
-
 void ServiceManagementService::purchaseService(const util::Vector<std::string>& serviceIDs, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
 {
 	AuthenticationManagementService m_authenticationManagementService;
@@ -270,11 +60,22 @@ void ServiceManagementService::purchaseService(const util::Vector<std::string>&
 		throw std::runtime_error("Failed to create service booking");
 	}
 	serviceBookingMap[serviceBooking->getId()] = serviceBooking;
-	sendNotification(authenticatedUser,
+    std::string title = "Service Booking succeeded";
-		"Service Booking succeeded",
+    std::string message = "Your service booking has been successfully placed with ID " + serviceBooking->getId();
-		"Your service booking has been successfully placed with ID " + serviceBooking->getId());
+    sendNotification(authenticatedUser, title, message);
 }
 
+/*
+Function: purchaseComboPackage
+Description: Creates a new service booking for a combo package. Validates the combo
+			 package ID, retrieves services from the package, and generates a booking
+			 with the applicable discount. Sends a notification upon successful booking.
+Parameter: const std::string& comboPackageID - ID of the combo package
+		   const std::string& vehicleNumber - vehicle registration number
+		   const std::string& vehicleBrand - brand of the vehicle
+		   const std::string& vehicleModel - model of the vehicle
+Return type: void
+*/
 void ServiceManagementService::purchaseComboPackage(const std::string& comboPackageID, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
 {
 	AuthenticationManagementService m_authenticationManagementService;
@@ -298,225 +99,12 @@ void ServiceManagementService::purchaseComboPackage(const std::string& comboPack
 		throw std::runtime_error("Failed to create combo package service booking");
 	}
 	serviceBookingMap[serviceBooking->getId()] = serviceBooking;
-	sendNotification(authenticatedUser,
+    std::string title = "Combo Package Service Booking succeeded";
-		"Combo Package Service Booking succeeded",
+    std::string message = "Your service booking for the combo package has been successfully placed with ID " + serviceBooking->getId();
-		"Your service booking for the combo package has been successfully placed with ID " + serviceBooking->getId());
+    sendNotification(authenticatedUser, title, message);
 }
 
-/*
+util::Map<std::string, User*> ServiceManagementService::m_observers{};
-Function: cancelCustomerServiceBookings
-Description: Cancels all service bookings associated with a given customer or technician.
-             Updates booking status, resets customer/technician assignments, sends notifications,
-             and restocks inventory items.
-Parameter: const std::string& userID - ID of the customer or technician
-Return type: void
-*/
-void ServiceManagementService::cancelCustomerServiceBookings(const std::string& userID)
-{
-    const int INCREMENT_VALUE = 1;
-    auto& users = m_dataStore.getUsers();
-    int userIndex = users.find(userID);
-    if (userIndex == -1)
-    {
-        throw std::runtime_error("User not found: " + userID);
-    }
-    User* user = users.getValueAt(userIndex);
-    if (user == nullptr)
-    {
-        throw std::runtime_error("User not found: " + userID);
-    }
-    util::UserType type = user->getUserType();
-    auto& bookings = DataStore::getInstance().getServiceBookings();
-    for (int bookingIterator = 0; bookingIterator < bookings.getSize(); bookingIterator++)
-    {
-        ServiceBooking* booking = bookings.getValueAt(bookingIterator);
-        if (booking != nullptr &&
-            (booking->getCustomerId() == userID || booking->getAssignedTechnicianId() == userID))
-        {
-            if (booking->getStatus() == util::ServiceJobStatus::PENDING ||
-                booking->getStatus() == util::ServiceJobStatus::STARTED)
-            {
-                if (type == util::UserType::CUSTOMER)
-                {
-                    booking->setStatus(util::ServiceJobStatus::CANCELLED);
-                    booking->setCustomer(nullptr);
-                    booking->setCustomerId("");
-                    User* assignedTechnician = booking->getAssignedTechnician();
-                    sendNotification(assignedTechnician, "Customer Service Cancelled", "Uh?Oh. The customer has cancelled their service booking. Your assigned job card has been cancelled and the inventory has been restocked.");
-                }
-                else if (type == util::UserType::TECHNICIAN)
-                {
-                    booking->setStatus(util::ServiceJobStatus::PENDING);
-                    sendNotification(booking->getCustomer(), "Technician Unavailable", "Your assigned technician is no longer available. Your booking has been reset to pending, and we will reassign a new technician shortly.");
-                }
-                booking->setAssignedTechnician(nullptr);
-                booking->setAssignedTechnicianId("");
-                const auto& ListOfServices = booking->getServices();
-                for (int serviceIterator = 0; serviceIterator < ListOfServices.getSize(); serviceIterator++)
-                {
-                    Service* service = ListOfServices.getValueAt(serviceIterator);
-                    if (service != nullptr)
-                    {
-                        const auto& items = service->getRequiredInventoryItems();
-                        for (int itemIterator = 0; itemIterator < items.getSize(); itemIterator++)
-                        {
-                            InventoryItem* item = items.getValueAt(itemIterator);
-                            if (item != nullptr)
-                            {
-                                item->setQuantity(item->getQuantity() + INCREMENT_VALUE);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-/*
-Function: cancelTechnicianJobs
-Description: Cancels all jobs assigned to a technician. Updates job status, sends notifications,
-             and restocks inventory items used in the service.
-Parameter: const std::string& technicianID - ID of the technician
-Return type: void
-*/
-void ServiceManagementService::cancelTechnicianJobs(const std::string& technicianID)
-{
-    const int INCREMENT_VALUE = 1;
-    auto& jobs = m_dataStore.getJobCards();
-    for (int jobIterator = 0; jobIterator < jobs.getSize(); jobIterator++)
-    {
-        JobCard* job = jobs.getValueAt(jobIterator);
-        if (job != nullptr && job->getTechnicianId() == technicianID)
-        {
-            if (job->getStatus() == util::ServiceJobStatus::PENDING || job->getStatus() == util::ServiceJobStatus::STARTED)
-            {
-                job->setStatus(util::ServiceJobStatus::CANCELLED);
-                sendNotification(job->getTechnician(), "Job Cancelled", "The Job has cancelled. Your job card has been cancelled and the inventory has been restocked.");
-                Service* service = job->getService();
-                if (service != nullptr)
-                {
-                    const auto& items = service->getRequiredInventoryItems();
-                    for (int itemIterator = 0; itemIterator < items.getSize(); itemIterator++)
-                    {
-                        InventoryItem* item = items.getValueAt(itemIterator);
-                        if (item != nullptr)
-                        {
-                            item->setQuantity(item->getQuantity() + INCREMENT_VALUE);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-/*
-Function: createComboPackage
-Description: Creates a new combo package with two services and a discount percentage.
-             Validates service IDs, ensures uniqueness, and inserts the new package into the DataStore.
-Parameter: const std::string& packageName - name of the combo package
-           const util::Vector<std::string>& serviceIDsInNewCombo - list of service IDs
-           double discountPercentage - discount percentage for the package
-Return type: void
-*/
-void ServiceManagementService::createComboPackage(const std::string& packageName, const util::Vector<std::string>& serviceIDsInNewCombo, double discountPercentage)
-{
-    if (packageName.empty())
-    {
-        throw std::invalid_argument("The Combo Package Name cannot be empty.\n");
-    }
-    if (serviceIDsInNewCombo.getSize() < 2 || serviceIDsInNewCombo.getSize() > 2)
-    {
-        throw std::invalid_argument("Combo package must contain only two services.");
-    }
-    if (discountPercentage < 0.0 || discountPercentage > 100.0)
-    {
-        throw std::invalid_argument("Discount percentage must be between 0 and 100.");
-    }
-    auto& servicesMap = m_dataStore.getServices();
-    for (int index = 0; index < serviceIDsInNewCombo.getSize(); index++)
-    {
-        const std::string serviceid = serviceIDsInNewCombo[index];
-        if (servicesMap.find(serviceid) == -1)
-        {
-            throw std::runtime_error("Service ID not found: " + serviceid);
-        }
-    }
-    auto& comboPackageMap = m_dataStore.getComboPackages();
-    for (int iterator = 0; iterator < comboPackageMap.getSize(); iterator++)
-    {
-        ComboPackage* existingCombos = comboPackageMap.getValueAt(iterator);
-        const util::Map<std::string, Service*>& servicesInsideExistingCombos = existingCombos->getServices();
-        if (servicesInsideExistingCombos.getSize() == serviceIDsInNewCombo.getSize())
-        {
-            bool isIdentical = true;
-            for (int serviceIterator = 0; serviceIterator < serviceIDsInNewCombo.getSize(); serviceIterator++)
-            {
-                const std::string& id = serviceIDsInNewCombo[serviceIterator];
-                if (servicesInsideExistingCombos.find(id) == -1)
-                {
-                    isIdentical = false;
-                    break;
-                }
-            }
-            if (isIdentical)
-            {
-                throw std::runtime_error("A combo package with the same services already exists.");
-            }
-        }
-    }
-    util::Map<std::string, Service*> selectedServices;
-    for (int iteratorOne = 0; iteratorOne < serviceIDsInNewCombo.getSize(); iteratorOne++)
-    {
-        const std::string& serviceId = serviceIDsInNewCombo[iteratorOne];
-        int serviceIndex = servicesMap.find(serviceId);
-        if (serviceIndex == -1)
-        {
-            throw std::runtime_error("Service ID not found: " + serviceId);
-        }
-        selectedServices.insert(serviceId, servicesMap.getValueAt(serviceIndex));
-    }
-    ComboPackage* newComboPackage = Factory::getObject<ComboPackage>(packageName, discountPercentage, selectedServices);
-    comboPackageMap.insert(newComboPackage->getId(), newComboPackage);
-}
-
-/*
-Function: getComboPackages
-Description: Retrieves all combo packages stored in the DataStore.
-Parameter: None
-Return type: util::Map<std::string, ComboPackage*>
-*/
-util::Map<std::string, ComboPackage*> ServiceManagementService::getComboPackages()
-{
-    return m_dataStore.getComboPackages();
-}
-
-/*
-Function: removeComboPackage
-Description: Removes a combo package by marking it inactive. Throws an exception if the package ID is not found.
-Parameter: const std::string& comboPackageID - ID of the combo package
-Return type: void
-*/
-void ServiceManagementService::removeComboPackage(const std::string& comboPackageID)
-{
-    bool removed = false;
-    util::Map<std::string, ComboPackage*>& currentComboPackages = m_dataStore.getComboPackages();
-    for (int iterator = 0; iterator < currentComboPackages.getSize(); iterator++)
-    {
-        ComboPackage* currentComboPackage = currentComboPackages.getValueAt(iterator);
-        if (currentComboPackage && currentComboPackage->getId() == comboPackageID)
-        {
-            currentComboPackage->setState(util::State::INACTIVE);
-            removed = true;
-            break;
-        }
-    }
-    if (!removed)
-    {
-        throw std::runtime_error("Combo package with ID '" + comboPackageID + "' not found.");
-    }
-}
 
 /*
 Function: attach
@@ -596,6 +184,15 @@ void ServiceManagementService::sendNotification(User* user, const std::string& t
 	}
 }
 
+/*
+Function: getObserverIDs
+Description: Retrieves the IDs of all observers currently attached to the
+             ServiceManagementService.
+Parameters:
+    - None
+Returns:
+    - util::Vector<std::string>: Vector of observer user IDs
+*/
 util::Vector<std::string> ServiceManagementService::getObserverIDs()
 {
 	util::Vector<std::string> observerIDs;
@@ -611,6 +208,17 @@ util::Vector<std::string> ServiceManagementService::getObserverIDs()
 	return observerIDs;
 }
 
+/*
+Function: loadServices
+Description: Loads services from persistent storage into the datastore.
+             Validates required inventory items and attaches them to each service.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if an inventory item ID is invalid
+*/
 void ServiceManagementService::loadServices()
 {
     util::FileManager<Service> serviceFileManager(config::file::SERVICE_FILE);
@@ -637,6 +245,15 @@ void ServiceManagementService::loadServices()
     }
 }
 
+/*
+Function: saveServices
+Description: Saves services from the datastore to persistent storage.
+             Uses FileManager to serialize services into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
 void ServiceManagementService::saveServices()
 {
 	util::FileManager<Service> serviceFileManager(config::file::SERVICE_FILE);
@@ -644,6 +261,17 @@ void ServiceManagementService::saveServices()
 	serviceFileManager.save(services);
 }
 
+/*
+Function: loadComboPackages
+Description: Loads combo packages from persistent storage into the datastore.
+             Validates associated services and attaches them to each package.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a service ID is invalid
+*/
 void ServiceManagementService::loadComboPackages()
 {
     util::FileManager<ComboPackage> comboPackageFileManager(config::file::COMBOPACKAGE_FILE);
@@ -670,6 +298,15 @@ void ServiceManagementService::loadComboPackages()
     }
 }
 
+/*
+Function: saveComboPackages
+Description: Saves combo packages from the datastore to persistent storage.
+             Uses FileManager to serialize combo packages into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
 void ServiceManagementService::saveComboPackages()
 {
     util::FileManager<ComboPackage> comboPackageFileManager(config::file::COMBOPACKAGE_FILE);
@@ -677,6 +314,19 @@ void ServiceManagementService::saveComboPackages()
     comboPackageFileManager.save(comboPackages);
 }
 
+/*
+Function: loadServiceBookings
+Description: Loads service bookings from persistent storage into the datastore.
+             Validates associated services, customers, and technicians before
+             attaching them to each booking.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a service ID, customer ID, or technician ID is invalid
+    - std::runtime_error if a user is not of the expected type (customer/technician)
+*/
 void ServiceManagementService::loadServiceBookings()
 {
     util::FileManager<ServiceBooking> bookingFileManager(config::file::SERVICEBOOKING_FILE);
@@ -731,6 +381,15 @@ void ServiceManagementService::loadServiceBookings()
     }
 }
 
+/*
+Function: saveServiceBookings
+Description: Saves service bookings from the datastore to persistent storage.
+             Uses FileManager to serialize bookings into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
 void ServiceManagementService::saveServiceBookings()
 {
     util::FileManager<ServiceBooking> bookingFileManager(config::file::SERVICEBOOKING_FILE);
@@ -738,6 +397,20 @@ void ServiceManagementService::saveServiceBookings()
     bookingFileManager.save(serviceBookings);
 }
 
+/*
+Function: loadJobCards
+Description: Loads job cards from persistent storage into the datastore.
+             Validates associated bookings, services, and technicians before
+             attaching them to each job card.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a booking ID, service ID, or technician ID is invalid
+    - std::runtime_error if a service does not belong to the booking
+    - std::runtime_error if a user is not a technician
+*/
 void ServiceManagementService::loadJobCards()
 {
     util::FileManager<JobCard> jobCardFileManager(config::file::JOBCARD_FILE);
@@ -781,6 +454,16 @@ void ServiceManagementService::loadJobCards()
         jobCards[jobCard->getId()] = jobCard;
     }
 }
+
+/*
+Function: saveJobCards
+Description: Saves job cards from the datastore to persistent storage.
+             Uses FileManager to serialize job cards into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
 void ServiceManagementService::saveJobCards()
 {
     util::FileManager<JobCard> jobCardFileManager(config::file::JOBCARD_FILE);
@@ -788,12 +471,32 @@ void ServiceManagementService::saveJobCards()
     jobCardFileManager.save(jobCards);
 }
 
+/*
+Function: loadObservers
+Description: Loads observer IDs from persistent storage and attaches corresponding
+             users as observers to the ServiceManagementService.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if an observer ID is invalid (not found in datastore)
+*/
 void ServiceManagementService::loadObservers()
 {
     util::loadObservers(config::file::SERVICEMANAGEMENTOBSERVERS, this, m_dataStore);
 }
 
+/*
+Function: saveObservers
+Description: Saves the current observer IDs of the ServiceManagementService
+             to persistent storage for future retrieval.
+Parameters:
+    - None
+Returns:
+    - void
+*/
 void ServiceManagementService::saveObservers()
 {
     util::saveObservers(config::file::SERVICEMANAGEMENTOBSERVERS, this);
-}
+}

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

@@ -31,7 +31,6 @@ 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);
@@ -39,7 +38,7 @@ public:
     void completeJob(const std::string& jobID);
     void cancelCustomerServiceBookings(const std::string& customerID);
     void cancelTechnicianJobs(const std::string& technicianID);
-    void createComboPackage(const std::string& packageName, const util::Vector<std::string>& serviceIDs, double discountPercentage);
+    void createComboPackage(const std::string& name, const util::Vector<std::string>& serviceIDs, double discountPercentage);
     void removeComboPackage(const std::string& comboPackageID);
     void sendNotification(User* user, const std::string& title, const std::string& message) override;
     void attach(User* user) override;

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

@@ -1,25 +1,33 @@
 /*
 File: UserManagementService.cpp
 Description: Implementation file containing the method definitions of the
-			 UserManagementService class, including user retrieval and removal logic.
+			 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 "Invoice.h"
+#include "Notification.h"
 #include "PaymentManagementService.h"
 #include "ServiceManagementService.h"
 #include "User.h"
 #include "UserManagementService.h"
-#include "Utility.h"
 #include "Vector.h"
 
+
+/*
+Function: ensureAdminExists
+Description: Ensures that at least one admin user exists in the system.
+			 If no admin is found, creates a default admin user using
+			 configuration constants.
+Parameter: None
+Return type: void
+*/
 void UserManagementService::ensureAdminExists()
 {
 	auto& usersMap = m_dataStore.getUsers();
@@ -46,6 +54,19 @@ void UserManagementService::ensureAdminExists()
 	}
 }
 
+/*
+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;
@@ -72,6 +93,15 @@ void UserManagementService::createUser(const std::string& username, const std::s
 	}
 }
 
+/*
+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();
@@ -85,67 +115,6 @@ void UserManagementService::updateUserDetails(const std::string& userID, const s
 	user->setPhone(phone);
 }
 
-/*
-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();
-}
-
-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->getUserType() == type)
-		{
-			filteredUsersMap.insert(currentUser->getId(), currentUser);
-		}
-	}
-	return filteredUsersMap;
-}
-
-/*
-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)
-{
-	int index = m_dataStore.getUsers().find(userID);
-	if (index != -1)
-	{
-		User* user = m_dataStore.getUsers().getValueAt(index);
-		if (user != nullptr)
-		{
-			user->setState(util::State::INACTIVE);
-		}
-	}
-}
-
 /*
 Function: getUserNotifications
 Description: Retrieves all notifications associated with a given user ID.
@@ -171,7 +140,7 @@ util::Vector<Notification*> UserManagementService::getUserNotifications(const st
 		util::Vector<Notification*> notificationsVector;
 		for (int index = 0; index < numberOfNotifications; index++)
 		{
-			notificationsVector.push_back(notifications.getValueAt(index));
+		    notificationsVector.push_back(notifications.getValueAt(index));
 		}
 		return notificationsVector;
 	}
@@ -208,6 +177,18 @@ void UserManagementService::deleteNotification(const std::string& notificationID
 	notifications.remove(notificationID);
 }
 
+/*
+Function: loadUsers
+Description: Loads users and notifications from persistent storage into the datastore.
+             Validates that each notification’s recipient exists and attaches the
+             notification to the corresponding user.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a notification recipient user ID is invalid
+*/
 void UserManagementService::loadUsers()
 {
     util::FileManager<User> userFileManager(config::file::USER_FILE);
@@ -235,6 +216,15 @@ void UserManagementService::loadUsers()
     }
 }
 
+/*
+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);
@@ -253,4 +243,4 @@ void UserManagementService::saveUsers()
     }
     userFileManager.save(users);
     notificationFileManager.save(notifications);
-}
+}

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

@@ -1,7 +1,8 @@
 /*
 File: UserManagementService.h
 Description: Header file declaring the UserManagementService class, which manages
-             user creation, updates, retrieval, removal, and notification handling.
+             user creation, updates, retrieval, removal, notifications, and ensures
+             the existence of an admin account.
 Author: Trenser
 Date:19-May-2026
 */

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

@@ -1,7 +1,8 @@
 /*
 File: Config.h
-Description: Defines configuration constants for system thresholds in the Vehicle Service Management System.
+Description: Header file declaring configuration constants for the Vehicle Service System.
-			 Includes limits for inventory stock alerts and payment reminder intervals.
+			 Includes default admin account details such as username, name, password,
+			 email, and phone number.
 Author: Trenser
 Date: 21-May-2026
 */
@@ -14,7 +15,7 @@ namespace config
 	{
 		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_PASSWORD = "";
 		constexpr const char* DEFAULT_ADMIN_EMAIL = "admin@vss";
 		constexpr const char* DEFAULT_ADMIN_PHONE = "0000000000";
 	}

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

@@ -22,8 +22,7 @@ namespace util
 	enum class PaymentMode
 	{
 		ONLINE,
-		OFFLINE,
+		OFFLINE
-        NOTSET
 	};
 
 	enum class PaymentStatus
@@ -34,10 +33,8 @@ namespace util
 
 	enum class ServiceJobStatus
 	{
-        PENDING,
 		STARTED,
-		COMPLETED,
+		COMPLETED
-        CANCELLED
 	};
 
     enum class State
@@ -111,8 +108,6 @@ namespace util
             return "ONLINE";
         case PaymentMode::OFFLINE:
             return "OFFLINE";
-        case PaymentMode::NOTSET:
-            return "NOTSET";
         }
         throw std::invalid_argument("Invalid PaymentMode");
     }
@@ -197,14 +192,10 @@ namespace util
     {
         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");
     }
@@ -229,14 +220,6 @@ namespace util
         {
             return ServiceJobStatus::COMPLETED;
         }
-        if (value == "PENDING")
-        {
-            return ServiceJobStatus::PENDING;
-        }
-        if (value == "CANCELLED")
-        {
-            return ServiceJobStatus::CANCELLED;
-        }
         throw std::invalid_argument("Invalid ServiceJobStatus string");
     }
 

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

@@ -1,3 +1,12 @@
+/*
+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>
@@ -6,6 +15,17 @@
 
 namespace util
 {
+    /*
+    Function: loadRecords
+    Description: Loads records from a given file path into a vector of strings.
+                 Skips the header line if present. Creates the file if it does not exist.
+    Parameters:
+        - filePath: const std::string&, path to the file
+    Returns:
+        - util::Vector<std::string>: Vector containing all records (excluding header)
+    Throws:
+        - None (creates file if missing)
+    */
     inline util::Vector<std::string> loadRecords(const std::string& filePath)
     {
         util::Vector<std::string> records;
@@ -30,6 +50,18 @@ namespace util
         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);

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

@@ -1,6 +1,17 @@
+/*
+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 <string>
 #include <stdexcept>
+#include <string>
 #include <fstream>
 #include "Vector.h"
 #include "Map.h"
@@ -21,6 +32,18 @@ namespace util
 		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()
 	{
@@ -58,6 +81,17 @@ namespace util
 		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)
 	{

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

@@ -1,8 +1,26 @@
+/*
+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;

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

@@ -1,17 +1,18 @@
 /*
 File: Utility.h
 Description: Header file declaring utility functions used across the system,
-             including cost calculation for services based on required inventory items.
+             including cost calculation for services and combo packages.
 Author: Trenser
 Date:19-May-2026
 */
+
 #pragma once
-#include "Service.h"
+#include "DataStore.h"
-#include "ComboPackage.h"
+#include "FileHelper.h"
 #include "InventoryItem.h"
 #include "NotificationManagementService.h"
-#include "FileHelper.h"
+#include "Service.h"
-#include "DataStore.h"
+#include "ComboPackage.h"
 
 namespace util
 {
@@ -37,11 +38,9 @@ namespace util
     /*
     Function: calculateComboServiceEstimatedCost
     Description: Calculates the estimated total cost of a combo package by summing
-                 the labor cost and parts cost of all services included in the package.
+                  the labor and parts costs of all services included in the package.
-    Parameters:
+    Parameter: const ComboPackage* comboPackage - pointer to the combo package object
-        - comboPackage: const ComboPackage*, pointer to the combo package whose cost is to be estimated
+    Return type: double - estimated total cost of the combo package
-    Returns:
-        - double: The estimated total cost of the combo package
     */
     inline double calculateComboServiceEstimatedCost(const ComboPackage* comboPackage)
     {
@@ -56,6 +55,20 @@ namespace util
         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);
@@ -72,6 +85,16 @@ namespace util
         }
     }
 
+    /*
+    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();

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

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

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

@@ -1,41 +1,30 @@
 /*
 File: CustomerMenu.cpp
-Description: Implements the CustomerMenu class which provides the customer’s console interface
+Description: Implementation file containing the method definitions of the
-             in the Vehicle Service Management System. Handles menu display, user input, and
+             CustomerMenu class, including menu handling, service selection,
-             customer-specific operations such as booking services, viewing history, managing payments,
+             combo package booking, profile updates, and password management.
-             invoices, and notifications.
 Author: Trenser
-Date: 19-May-2026
+Date:19-May-2026
 */
-
 #include <iomanip>
-#include <iostream>
 #include "ComboPackage.h"
 #include "CustomerMenu.h"
-#include "Enums.h"
 #include "InputHelper.h"
 #include "InventoryItem.h"
-#include "Invoice.h"
 #include "Map.h"
 #include "MenuHelper.h"
 #include "OutputHelper.h"
 #include "Service.h"
-#include "ServiceBooking.h"
-#include "Timestamp.h"
-#include "User.h"
-#include "Utility.h"
 #include "Validator.h"
 #include "Vector.h"
 
 /*
 Function: showMenu
-Description: Displays the customer menu in a loop until the user chooses to logout.
+Description: Displays the customer menu and handles user input until logout is selected.
-             Handles exceptions and ensures smooth user interaction.
+Parameter: None
-Parameters:
+Return type: void
-    - None
-Returns:
-    - void
 */
+
 void CustomerMenu::showMenu()
 {
     while (true)
@@ -70,6 +59,12 @@ void CustomerMenu::showMenu()
     }
 }
 
+/*
+Function: handleOperation
+Description: Executes the corresponding customer operation based on the selected menu choice.
+Parameter: int choice - selected menu option
+Return type: bool - true if menu continues, false if logout
+*/
 bool CustomerMenu::handleOperation(int choice)
 {
     switch (choice)
@@ -111,28 +106,34 @@ bool CustomerMenu::handleOperation(int choice)
     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()
 {
-	std::string newPassword;
+    changePasswordHelper(m_controller);
-	util::clear();
-	std::cout << "Enter new password: ";
-	util::read(newPassword);
-	m_controller.changePassword(newPassword);
-	if (!util::isPasswordValid(newPassword))
-	{
-		std::cout << "Error: Password is not strong enough!";
-		util::pressEnter();
-		return;
-	}
-	std::cout << "Password changed successfully";
-	util::pressEnter();
 }
 
+/*
+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;
@@ -158,49 +159,13 @@ void CustomerMenu::updateDetails()
 	util::pressEnter();
 }
 
-static const Service* selectServiceFromServices(const util::Map<std::string, const Service*>& services)
+/*
-{
+Function: selectService
-    util::Map<int, const Service*> activeServicesMap;
+Description: Allows the customer to select a service, provide vehicle details,
-    int currentIndex = 1;
+             and book the service through the controller.
-    int userInputIndex;
+Parameter: None
-    std::cout << std::left
+Return type: void
-        << std::setw(10) << "Index"
+*/
-        << std::setw(15) << "Service ID"
-        << std::setw(25) << "Service Name"
-        << std::setw(15) << "Estimated Cost"
-        << std::endl;
-    for (int index = 0; index < services.getSize(); index++)
-    {
-        const Service* currentService = services.getValueAt(index);
-        if (currentService->getState() != util::State::ACTIVE)
-        {
-            continue;
-        }
-        activeServicesMap.insert(currentIndex, currentService);
-        double partsCost = util::calculatePartsCost(currentService);
-        std::cout << std::left
-            << std::setw(10) << currentIndex
-            << std::setw(15) << currentService->getId()
-            << std::setw(25) << currentService->getName()
-            << std::setw(15) << (currentService->getLaborCost() + partsCost)
-            << std::endl;
-        currentIndex++;
-    }
-    if (activeServicesMap.getSize() == 0)
-    {
-        std::cout << "No active services available." << std::endl;
-        return nullptr;
-    }
-    std::cout << "Enter service index: ";
-    util::read(userInputIndex);
-    if (activeServicesMap.find(userInputIndex) == -1)
-    {
-        std::cout << "Invalid service index." << std::endl;
-        return nullptr;
-    }
-    return activeServicesMap[userInputIndex];
-}
-
 void CustomerMenu::selectService()
 {
     std::string vehicleNumber, vehicleBrand, vehicleModel;
@@ -227,48 +192,13 @@ void CustomerMenu::selectService()
     util::pressEnter();
 }
 
-static const ComboPackage* selectComboPackageFromPackages(const util::Map<std::string, const ComboPackage*>& comboPackages)
+/*
-{
+Function: selectComboPackage
-    util::Map<int, const ComboPackage*> activeComboPackages;
+Description: Allows the customer to select a combo package, provide vehicle details,
-    int currentIndex = 1;
+             and book the package through the controller.
-    int userInputIndex;
+Parameter: None
-    std::cout << std::left
+Return type: void
-        << std::setw(10) << "Index"
+*/
-        << std::setw(15) << "Combo Package ID"
-        << std::setw(15) << "Combo Package Name"
-        << std::setw(15) << "Estimate Cost"
-        << std::endl;
-    for (int index = 0; index < comboPackages.getSize(); index++)
-    {
-        const ComboPackage* currentComboPackage = comboPackages.getValueAt(index);
-        if (currentComboPackage->getState() != util::State::ACTIVE)
-        {
-            continue;
-        }
-        activeComboPackages.insert(currentIndex, currentComboPackage);
-        std::cout << std::left
-            << std::setw(10) << currentIndex
-            << std::setw(15) << currentComboPackage->getId()
-            << std::setw(25) << currentComboPackage->getPackageName()
-            << std::setw(15) << util::calculateComboServiceEstimatedCost(currentComboPackage)
-            << std::endl;
-        currentIndex++;
-    }
-    if (activeComboPackages.getSize() == 0)
-    {
-        std::cout << "No active combo packages available." << std::endl;
-        return nullptr;
-    }
-    std::cout << "Enter combo package index: ";
-    util::read(userInputIndex);
-    if (activeComboPackages.find(userInputIndex) == -1)
-    {
-        std::cout << "Invalid combo package index." << std::endl;
-        return nullptr;
-    }
-    return activeComboPackages[userInputIndex];
-}
-
 void CustomerMenu::selectComboPackage()
 {
     std::string vehicleNumber, vehicleBrand, vehicleModel;
@@ -295,193 +225,14 @@ void CustomerMenu::selectComboPackage()
 
 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);
-    if (serviceBookingsByCurrentUser.getSize() != 0)
-    {
-        std::cout << std::left
-            << std::setw(12) << "Booking ID"
-            << std::setw(20) << "Technician"
-            << std::setw(15) << "Vehicle Brand"
-            << std::setw(15) << "Vehicle Number"
-            << std::setw(15) << "Vehicle Model"
-            << std::setw(10) << "Discount %"
-            << std::setw(12) << "Status"
-            << std::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(12) << currentBooking->getId()
-                << std::setw(20) << technicianName
-                << std::setw(15) << currentBooking->getVehicleBrand()
-                << std::setw(15) << currentBooking->getVehicleNumber()
-                << std::setw(15) << currentBooking->getVehicleModel()
-                << std::setw(10) << currentBooking->getDiscountPercentage()
-                << std::setw(12) << util::getServiceJobStatusString(currentBooking->getStatus())
-                << std::endl;
-            hasServiceHistory = true;
-        }
-    }
-    if (!hasServiceHistory)
-    {
-        std::cout << "No history available." << std::endl;
-    }
-}
-
-static std::string selectInvoiceFromUserForPayment(const util::Map<std::string, const Invoice*>& currentInvoices)
-{
-    int currentIndex = 1, choice;
-    util::Map<int, const Invoice*> pendingInvoicesForPayment;
-    std::cout << std::left
-        << std::setw(6) << "Index"
-        << std::setw(12) << "BookingID"
-        << std::setw(15) << "VehicleBrand"
-        << std::setw(15) << "VehicleNumber"
-        << std::setw(12) << "TechID"
-        << std::setw(20) << "TechnicianName"
-        << std::setw(10) << "Discount(%)"
-        << std::setw(12) << "TotalAmount"
-        << std::setw(20) << "InvoiceDate"
-        << std::endl;
-    for (int iterator = 0; iterator < currentInvoices.getSize(); iterator++)
-    {
-        const Invoice* currentInvoice = currentInvoices.getValueAt(iterator);
-        if (currentInvoice && currentInvoice->getStatus() == util::PaymentStatus::PENDING)
-        {
-            std::cout << std::left
-                << std::setw(6) << currentIndex
-                << std::setw(12) << currentInvoice->getBookingId()
-                << std::setw(15) << currentInvoice->getBooking()->getVehicleBrand()
-                << std::setw(15) << currentInvoice->getBooking()->getVehicleNumber()
-                << std::setw(12) << currentInvoice->getBooking()->getAssignedTechnician()->getId()
-                << std::setw(20) << currentInvoice->getBooking()->getAssignedTechnician()->getName()
-                << std::setw(10) << currentInvoice->getDiscountPercentage()
-                << std::setw(12) << currentInvoice->getTotalAmount()
-                << std::setw(20) << currentInvoice->getInvoiceDate().toString()
-                << std::endl;
-            pendingInvoicesForPayment.insert(currentIndex++, currentInvoice);
-        }
-    }
-    if (pendingInvoicesForPayment.getSize() == 0)
-    {
-        std::cout << "No pending invoices available for payment.\n";
-        return "";
-    }
-    std::cout << "Select the Invoice to pay (Index): ";
-    util::read(choice);
-    int selectedIndex = pendingInvoicesForPayment.find(choice);
-    if (selectedIndex != -1)
-    {
-        const Invoice* selectedInvoice = pendingInvoicesForPayment.getValueAt(selectedIndex);
-        return selectedInvoice->getId();
-    }
-    else
-    {
-        std::cout << "Invalid choice.\n";
-        return "";
-    }
-}
-
-static util::PaymentMode selectPaymentMode()
-{
-    int choice;
-    std::cout << "Enter the payment Mode\n1.OFFLINE\n2.ONLINE\nChoice: ";
-    util::read(choice);
-    if (choice == 1)
-    {
-        std::cout << "Offline mode selected.\n";
-        return util::PaymentMode::OFFLINE;
-    }
-    else if (choice == 2)
-    {
-        std::cout << "Online mode selected.\n";
-        return util::PaymentMode::ONLINE;
-    }
-    else
-    {
-        std::cout << "Invalid choice, Offline mode selected.\n";
-        return util::PaymentMode::OFFLINE;
-    }
 }
 
 void CustomerMenu::completePayments()
 {
-	util::clear();
-	util::Map<std::string, const Invoice*> currentInvoices = m_controller.getInvoicesByUser();
-	std::string selectedID = selectInvoiceFromUserForPayment(currentInvoices);
-    if (selectedID == "")
-    {
-        std::cout << "Payment failed.\n";
-        return;
-    }
-    util::PaymentMode paymentMode = selectPaymentMode();
-    m_controller.completePayment(selectedID, paymentMode);
-    std::cout << "Payment completed successfully.\n";
-}
-
-static void displayInvoices(util::Map<std::string, const Invoice*> currentUserInvoices)
-{
-	if (currentUserInvoices.getSize() == 0)
-	{
-		std::cout << "No invoices found for this account." << std::endl;
-		util::pressEnter();
-		return;
-	}
-	else
-	{
-        for (int index = 0; index < currentUserInvoices.getSize(); index++)
-        {
-            const Invoice* currentInvoice = currentUserInvoices.getValueAt(index);
-            if (currentInvoice)
-            {
-                std::cout << "\nInvoice Details\n";
-                std::cout << "Booking ID: " << currentInvoice->getBookingId() << std::endl;
-                std::cout << "Vehicle Brand: " << currentInvoice->getBooking()->getVehicleBrand() << std::endl;
-                std::cout << "Vehicle Number: " << currentInvoice->getBooking()->getVehicleNumber() << std::endl;
-                std::cout << "Technician ID: " << currentInvoice->getBooking()->getAssignedTechnician()->getId() << std::endl;
-                std::cout << "Technician Name: " << currentInvoice->getBooking()->getAssignedTechnician()->getName() << std::endl;
-                std::cout << "Discount(%): " << currentInvoice->getDiscountPercentage() << std::endl;
-                std::cout << "Total Amount: " << currentInvoice->getTotalAmount() << std::endl;
-                std::cout << "Invoice Date: " << currentInvoice->getInvoiceDate().toString() << std::endl;
-                std::cout << "Payment Status: " << util::getPaymentStatusString(currentInvoice->getStatus()) << std::endl;
-                auto inventoryItemsInInvoice = currentInvoice->getParts();
-                std::cout << "\nItems Used:\n";
-                std::cout << std::left
-                    << std::setw(20) << "ItemName"
-                    << std::setw(10) << "Quantity"
-                    << std::setw(10) << "Price"
-                    << std::endl;
-                std::cout << std::string(40, '-') << std::endl;
-                for (int iterator = 0; iterator < inventoryItemsInInvoice.getSize(); iterator++)
-                {
-                    InventoryItem* currentItem = inventoryItemsInInvoice.getValueAt(iterator);
-                    std::cout << std::left
-                        << std::setw(20) << currentItem->getPartName()
-                        << std::setw(10) << currentItem->getQuantity()
-                        << std::setw(10) << currentItem->getPrice()
-                        << std::endl;
-                }
-            }
-            else
-            {
-                throw std::runtime_error("Null invoice encountered while displaying invoices.");
-            }
-        }
-	}
 }
 
 void CustomerMenu::viewInvoices()
 {
-	util::clear();
-	util::Map<std::string, const Invoice*> currentUserInvoices = m_controller.getInvoicesByUser();
-	displayInvoices(currentUserInvoices);
 }
 
 /*
@@ -497,38 +248,6 @@ void CustomerMenu::viewNotifications()
 	viewAndDeleteNotification(m_controller);
 }
 
-/*
-Function: getNotificationPreference (static helper)
-Description: Helper function to configure notification preferences for a specific service.
-Parameters:
-    - serviceName: Name of the service for which notifications are being configured.
-Returns:
-    - bool: True if notifications are enabled, False if disabled.
-*/
-static bool getNotificationPreference(const std::string& serviceName)
-{
-    int choice;
-    while (true)
-    {
-        util::clear();
-        std::cout << "    Configure Notification Preferences\n";
-        std::cout << "\n" << serviceName << " Notifications\n";
-        std::cout << "1. Enable Notifications\n";
-        std::cout << "2. Disable Notifications\n";
-        std::cout << "Enter your choice: ";
-        util::read(choice);
-        if (choice == 1)
-        {
-            return true;
-        }
-        if (choice == 2)
-        {
-            return false;
-        }
-        std::cout << "\nInvalid choice. Please enter 1 or 2.\n";
-        util::pressEnter();
-    }
-}
 
 /*
 Function: configureNotifications

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

@@ -1,10 +1,11 @@
 /*
 File: CustomerMenu.h
-Description: Declares the CustomerMenu class which provides the customer-facing console menu in the Vehicle Service Management System.
+Description: Header file declaring the CustomerMenu class, which provides
-             Supports operations such as account management, service selection, combo package booking, viewing service history,
+             customer operations such as selecting services, booking combo
-             handling payments and invoices, and managing notifications.
+             packages, updating profile details, managing payments, viewing
+             invoices, and configuring notifications.
 Author: Trenser
-Date: 19-May-2026
+Date:19-May-2026
 */
 
 #pragma once

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

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

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

@@ -1,21 +1,16 @@
 /*
 File: TechnicianMenu.cpp
-Description: Implementation file containing the method definitions of the
+Description: Implements the TechnicianMenu class which provides the technician’s console interface
-             TechnicianMenu class, including menu handling, job completion,
+			 in the Vehicle Service Management System. Handles menu display, user input, and
-             notification viewing, password management, and logout logic.
+			 technician-specific operations such as completing jobs and viewing notifications.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
 
-#include <iomanip>
-#include "Enums.h"
-#include "InputHelper.h"
-#include "JobCard.h"
-#include "MenuHelper.h"
-#include "OutputHelper.h"
-#include "Service.h"
 #include "TechnicianMenu.h"
-#include "Validator.h"
+#include "InputHelper.h"
+#include "OutputHelper.h"
+#include "MenuHelper.h"
 
 /*
 Function: showMenu
@@ -28,124 +23,35 @@ Returns:
 */
 void TechnicianMenu::showMenu()
 {
-    while (true)
+	bool isMenuActive = true;
-    {
+	while (isMenuActive)
-        try
+	{
-        {
+		try
-            int choice;
+		{
-            util::clear();
+			int choice;
-            std::cout << "Technician Menu"
+			util::clear();
-                << "\n1. Mark Job as Completed"
+			std::cout << "" << std::endl;
-                << "\n2. View Notifications"
+			util::read(choice);
-                << "\n3. Change Password"
+			if (!handleOperation(choice))
-                << "\n4. Logout"
+			{
-                << "\nEnter a choice: ";
+				isMenuActive = false;
-            util::read(choice);
+			}
-            if (!handleOperation(choice))
+		}
-            {
+		catch (const std::exception& e)
-                break;
+		{
-            }
+			std::cout << "Exception: " << e.what() << std::endl;
-        }
+			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)
 {
-    switch (choice)
+	return false;
-    {
-    case 1:
-        completeJob();
-        break;
-    case 2:
-        viewNotifications();
-        break;
-    case 3:
-        changePassword();
-        break;
-    case 4:
-        logout();
-        return false;
-    default:
-        std::cout << "Enter a valid choice!" << std::endl;
-        util::pressEnter();
-    }
-    return true;
 }
 
-static std::string selectJobCardToComplete(util::Map<std::string, const JobCard*>& assignedJobCards, util::Map<int, const JobCard*>& incompleteJobCards)
-{
-    int currentIndex = 1;
-    int choice;
-    bool hasIncompleteJobCard = false;
-    std::cout << std::left
-        << std::setw(6) << "Index"
-        << std::setw(12) << "BookingID"
-        << std::setw(12) << "JobID"
-        << std::setw(20) << "ServiceName"
-        << std::setw(12) << "ServiceID"
-        << std::endl;
-    for (int iterator = 0; iterator < assignedJobCards.getSize(); iterator++)
-    {
-        const JobCard* currentJobCard = assignedJobCards.getValueAt(iterator);
-        if (currentJobCard && (currentJobCard->getStatus() == util::ServiceJobStatus::STARTED))
-        {
-            std::cout << std::left << std::setw(6) << currentIndex
-                << std::setw(12) << currentJobCard->getBookingId()
-                << std::setw(12) << currentJobCard->getId()
-                << std::setw(20) << currentJobCard->getService()->getName()
-                << std::setw(12) << currentJobCard->getServiceId()
-                << std::endl;
-            hasIncompleteJobCard = true;
-            incompleteJobCards.insert(currentIndex++, currentJobCard);
-        }
-    }
-    if (!hasIncompleteJobCard)
-    {
-        std::cout << "No pending jobs are present.\n";
-        return "";
-    }
-    std::cout << "Select the Job Card to complete (Index): ";
-    util::read(choice);
-    int selectedJobCardIndex = incompleteJobCards.find(choice);
-    if (selectedJobCardIndex != -1)
-    {
-        const JobCard* selectedJobCard = incompleteJobCards.getValueAt(selectedJobCardIndex);
-        return selectedJobCard->getId();
-    }
-    else
-    {
-        std::cout << "Invalid choice.\n";
-        return "";
-    }
-}
-
-
 void TechnicianMenu::completeJob()
 {
-	util::Map<std::string, const JobCard*> assignedJobCards = m_controller.getJobCardsByUser();
-	util::Map<int, const JobCard*> incompleteJobCards;
-	std::cout << "Jobs to be completed.\n";
-	std::string selectedJobID = selectJobCardToComplete(assignedJobCards, incompleteJobCards);
-	if (selectedJobID == "")
-	{
-		std::cout << "Failed to complete the job.\n";
-	}
-	else
-	{
-		m_controller.completeJob(selectedJobID);
-		std::cout << "Job marked as completed.\n";
-	}
 }
 
 /*
@@ -160,41 +66,3 @@ void TechnicianMenu::viewNotifications()
 {
 	viewAndDeleteNotification(m_controller);
 }
-
-/*
-Function: logout
-Description: Logs out the currently authenticated technician user.
-Parameter: None
-Return type: void
-*/
-void TechnicianMenu::logout()
-{
-    m_controller.logout();
-}
-
-/*
-Function: changePassword
-Description: Allows the technician to change their password after validation.
-Parameter: None
-Return type: void
-*/
-void TechnicianMenu::changePassword()
-{
-    std::string newPassword;
-    while (true)
-    {
-        util::clear();
-        std::cout << "Enter new password: ";
-        util::read(newPassword);
-        if (!util::isPasswordValid(newPassword))
-        {
-            std::cout << "Error: Password is not strong enough!\n";
-            util::pressEnter();
-            continue;
-        }
-        m_controller.changePassword(newPassword);
-        std::cout << "Password changed successfully\n";
-        util::pressEnter();
-        break;
-    }
-}

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

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

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

@@ -5,11 +5,12 @@ Description: Implementation file containing the method definitions of the
 			 and customer registration logic.
 Author: Trenser
 Date:19-May-2026
+
 */
 #include "UserInterface.h"
-#include "Enums.h"
 #include "InputHelper.h"
 #include "OutputHelper.h"
+#include "Enums.h"
 #include "User.h"
 #include "Validator.h"
 
@@ -118,11 +119,11 @@ void UserInterface::login()
 
 /*
 Function: registerCustomer
-Description: Handles the registration process for new customers.
+Description: Registers a new customer by collecting and validating details such as
-Parameters:
+			 username, name, email, password, and phone number. Delegates creation
-	- None
+			 to the controller.
-Returns:
+Parameter: None
-	- void
+Return type: void
 */
 void UserInterface::registerCustomer()
 {