Implement review fixes

- Added verifyAllPaymentsCompleted() helper in MenuHelper.h to check if the authenticated customer has completed all invoices.

- Integrated payment verification into CustomerMenu::selectService() to block new service bookings when pending payments exist.

- Integrated payment verification into CustomerMenu::selectComboPackage() to block new combo package bookings when invoices are incomplete.

- Implemented iteration over customer invoices to ensure only users with all payments marked as COMPLETED can proceed with new bookings.

- Added user-facing messages to inform customers when bookings are denied due to outstanding payments.

Fixes #2116

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

@@ -234,6 +234,17 @@ void Controller::removeInventoryItem(const std::string& inventoryItemID)
     m_inventoryManagementService.removeInventoryItem(inventoryItemID);
 }
 
+/*
+Function: removeServiceBooking
+Description: Removes a service booking from the service management system by its booking ID.
+Parameter: const std::string& bookingID - ID of the service booking
+Return type: void
+*/
+void Controller::removeServiceBooking(const std::string& bookingID)
+{
+    m_serviceManagementService.removeServiceBooking(bookingID);
+}
+
 /*
 Function: addInventoryItemStock
 Description: Adds stock to an existing inventory item in the inventory management service.
@@ -265,6 +276,7 @@ util::Map<std::string, const ServiceBooking*> Controller::getServiceBookings()
     return readOnlyServiceBookings;
 }
 
+
 /*
 Function: getServiceBookingsByUser
 Description: Retrieves all service bookings for a specific user.

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

@@ -58,6 +58,7 @@ public:
     util::Map<std::string, const User*> getUsers(util::UserType userType);
     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 removeServiceBooking(const std::string& bookingID);
     void removeService(const std::string& serviceID);
     util::Map<std::string, const JobCard*> getJobCardsByUser();
     void updateJobStatus(const std::string& jobID);

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

@@ -415,7 +415,7 @@ util::Map<std::string, TrackedRecord<JobCard>>& DataStore::getJobCards()
         {
             throw std::runtime_error("Invalid booking ID: " + bookingId);
         }
-        auto trackedBooking = serviceBookings.getValueAt(bookingIndex);
+        auto& trackedBooking = serviceBookings.getValueAt(bookingIndex);
         jobCard->setBooking(trackedBooking.data);
         const std::string& serviceId = jobCard->getServiceId();
         int serviceIndex = services.find(serviceId);

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

@@ -26,7 +26,6 @@ Date:19-May-2026
 #include "UserManagementService.h"
 #include "DataStoreLockGuard.h"
 #include "Utility.h"
-#include "DataStoreLockGuard.h"
 #include "EventManager.h"
 
 /*
@@ -98,6 +97,7 @@ void ServiceManagementService::purchaseService(const util::Vector<std::string>&
     std::string title = "Service Booking succeeded";
     std::string message = "Your service booking has been successfully placed with ID " + serviceBooking->getId();
     sendNotification(authenticatedUser, title, message);
+    m_dataStore.saveServiceBookings();
     notifyAllAdmins("New Service Order Available", "A new service order has been placed with Service Booking ID " + serviceBooking->getId(), m_dataStore.getUsers(), this);
 }
 
@@ -140,6 +140,7 @@ void ServiceManagementService::purchaseComboPackage(const std::string& comboPack
     std::string title = "Combo Package Service Booking succeeded";
     std::string message = "Your service booking for the combo package has been successfully placed with ID " + serviceBooking->getId();
     sendNotification(authenticatedUser, title, message);
+    m_dataStore.saveServiceBookings();
     notifyAllAdmins("New Combo Package Order Available", "A new combo package order has been placed with Service Booking ID " + serviceBooking->getId(), m_dataStore.getUsers(), this);
 }
 
@@ -628,11 +629,23 @@ void ServiceManagementService::createJobCard(const std::string& bookingID, const
     DataStoreLockGuard lock(m_dataStore);
 	UserManagementService m_userManagementService;
 	ServiceBooking* currentBooking = getServiceBooking(bookingID);
+    if (currentBooking == nullptr)
+    {
+        throw std::runtime_error("Service Booking not available");
+    }
+    if (currentBooking->getStatus() == util::ServiceJobStatus::CANCELLED)
+    {
+        throw std::runtime_error("Cannot create job card. Service Booking was cancelled!");
+    }
 	auto& currentTrackedJobCards = m_dataStore.getJobCards();
-	if (currentBooking == nullptr)
-	{
-		throw std::runtime_error("Service Booking not available");
-	}
+    auto& currentTrackedInventoryItems = m_dataStore.getInventoryItems();
+    auto& currentTrackedServiceBookings = m_dataStore.getServiceBookings();
+    int currentTrackedServiceBookingIndex = currentTrackedServiceBookings.find(bookingID);
+    if (currentTrackedServiceBookingIndex == -1)
+    {
+        throw std::runtime_error("Invalid service booking id.");
+    }
+    auto& currentTrackedServiceBooking = currentTrackedServiceBookings.getValueAt(currentTrackedServiceBookingIndex);
 	auto& currentServices = currentBooking->getServices();
 	if (currentServices.find(serviceID) == -1)
 	{
@@ -657,10 +670,18 @@ void ServiceManagementService::createJobCard(const std::string& bookingID, const
 	for (int iterator = 0; iterator < inventoryItems.getSize(); iterator++)
 	{
 		InventoryItem* currentInventoryItem = inventoryItems.getValueAt(iterator);
+        const std::string& currentInventoryItemId = inventoryItems.getKeyAt(iterator);
 		if (currentInventoryItem)
 		{
+            int trackedCurrentInventoryItemIndex = currentTrackedInventoryItems.find(currentInventoryItemId);
+            if (trackedCurrentInventoryItemIndex == -1)
+            {
+                throw std::runtime_error("Invalid inventory item index.");
+            }
+            auto& trackedCurrentInventoryItem = currentTrackedInventoryItems.getValueAt(trackedCurrentInventoryItemIndex);
 			int currentStockQuantity = currentInventoryItem->getQuantity();
 			currentInventoryItem->setQuantity(currentStockQuantity - 1);
+            trackedCurrentInventoryItem.state = RecordState::MODIFIED;
 		}
 	}
 	currentBooking->setAssignedTechnician(selectedTechnician);
@@ -669,6 +690,7 @@ void ServiceManagementService::createJobCard(const std::string& bookingID, const
     {
         currentBooking->setStatus(util::ServiceJobStatus::STARTED);
     }
+    currentTrackedServiceBooking.state = RecordState::MODIFIED;
 	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());
@@ -685,6 +707,8 @@ void ServiceManagementService::createJobCard(const std::string& bookingID, const
     message = "A technician has been assigned to your Service Booking with ID " + bookingID;
     sendNotification(currentBooking->getCustomer(), title, message);
     m_dataStore.saveJobCards();
+    m_dataStore.saveServiceBookings();
+    m_dataStore.saveInventoryItems();
 }
 
 /*
@@ -806,6 +830,61 @@ void ServiceManagementService::removeService(const std::string& serviceID)
     m_dataStore.saveComboPackages();
 }
 
+/*
+Function: removeServiceBooking
+Description: Removes a pending service booking by its ID.
+             Cancels only if status is PENDING, otherwise throws exceptions
+             for invalid states. Sends notification to the customer and
+             persists changes.
+Parameter: const std::string& bookingID - ID of the service booking
+Return type: void
+*/
+void ServiceManagementService::removeServiceBooking(const std::string& bookingID)
+{
+    DataStoreLockGuard lock(m_dataStore);
+    auto& trackedServiceBookings = m_dataStore.getServiceBookings();
+    bool serviceBookingRemoved = false;
+    for (int iterator = 0; iterator < trackedServiceBookings.getSize(); iterator++)
+    {
+        auto& currentTrackedServiceBooking = trackedServiceBookings.getValueAt(iterator);
+        ServiceBooking* currentServiceBooking = currentTrackedServiceBooking.data;
+        if (currentServiceBooking && currentServiceBooking->getId() == bookingID)
+        {
+            if (currentServiceBooking->getStatus() == util::ServiceJobStatus::PENDING)
+            {
+                const std::string title = "Service Booking cancelled.";
+                const std::string message = "Service Booking of id " + bookingID + " successfully cancelled.";
+                currentServiceBooking->setStatus(util::ServiceJobStatus::CANCELLED);
+                currentTrackedServiceBooking.state = RecordState::MODIFIED;
+                serviceBookingRemoved = true;
+                sendNotification(currentServiceBooking->getCustomer(), title, message);
+                break;
+            }
+            else if(currentServiceBooking->getStatus() == util::ServiceJobStatus::COMPLETED)
+            {
+                throw std::runtime_error("Unable to cancel completed service booking.");
+            }
+            else if (currentServiceBooking->getStatus() == util::ServiceJobStatus::STARTED)
+            {
+                throw std::runtime_error("Unable to cancel started service booking.");
+            }
+            else if (currentServiceBooking->getStatus() == util::ServiceJobStatus::IN_PROGRESS)
+            {
+                throw std::runtime_error("Unable to cancel currently Inprogress service booking.");
+            }
+            else
+            {
+                throw std::runtime_error("Service Booking already cancelled.");
+            }
+        }
+    }
+    if (!serviceBookingRemoved)
+    {
+        throw std::runtime_error("Unable to cancel service booking.");
+    }
+    m_dataStore.saveServiceBookings();
+}
+
 /*
 Function: getServiceBookings (overloaded)
 Description: Retrieves all service bookings for a specific customer.
@@ -900,44 +979,44 @@ void ServiceManagementService::updateJobStatus(const std::string& jobID)
 {
     AuthenticationManagementService::ensureAuthorization();
     DataStoreLockGuard lock(m_dataStore);
-	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.");
-	}
+    AuthenticationManagementService authenticationManagementService;
+    PaymentManagementService paymentManagementService;
+    bool jobStatusUpdated = false, serviceBookingCompleted;
+    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.");
+    }
     auto& trackedJobCards = m_dataStore.getJobCards();
     auto& trackedServiceBookings = m_dataStore.getServiceBookings();
-	if (currentAssignedJobs.find(jobID) != -1)
-	{
+    if (currentAssignedJobs.find(jobID) != -1)
+    {
         int jobIndex = trackedJobCards.find(jobID);
         if (jobIndex == -1)
         {
             throw std::runtime_error("Unable to fetch current job.");
         }
-		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::IN_PROGRESS);
-            trackedJobCards.getValueAt(jobIndex).state = RecordState::MODIFIED;
-			jobStatusUpdated = true;
-		}
+        auto& trackedCurrentJob = trackedJobCards.getValueAt(jobIndex);
+        JobCard* currentJob = trackedCurrentJob.data;
+        if (currentJob == nullptr)
+        {
+            throw std::runtime_error("Unable to fetch current job.");
+        }
+        if (currentJob->getStatus() == util::ServiceJobStatus::STARTED)
+        {
+            currentJob->setStatus(util::ServiceJobStatus::IN_PROGRESS);
+            trackedCurrentJob.state = RecordState::MODIFIED;
+            jobStatusUpdated = true;
+        }
         else if (currentJob->getStatus() == util::ServiceJobStatus::IN_PROGRESS)
         {
             currentJob->setStatus(util::ServiceJobStatus::COMPLETED);
-            trackedJobCards.getValueAt(jobIndex).state = RecordState::MODIFIED;
+            trackedCurrentJob.state = RecordState::MODIFIED;
             jobStatusUpdated = true;
             serviceBookingCompleted = hasCompletedAllJobs(currentJob->getBookingId(), currentAssignedJobs);
             if (serviceBookingCompleted)
@@ -951,15 +1030,15 @@ void ServiceManagementService::updateJobStatus(const std::string& jobID)
                 sendNotification(currentJob->getBooking()->getCustomer(), title, message);
             }
         }
-	}
-	else
-	{
-		throw std::runtime_error("Failed to update job status. Job may already be completed.");
-	}
-	if (!jobStatusUpdated)
-	{
-		throw std::runtime_error("Failed to update job status. Job may already be completed.");
-	}
+    }
+    else
+    {
+        throw std::runtime_error("Failed to update job status. Job may already be completed.");
+    }
+    if (!jobStatusUpdated)
+    {
+        throw std::runtime_error("Failed to update job status. Job may already be completed.");
+    }
     m_dataStore.saveJobCards();
     m_dataStore.saveServiceBookings();
 }

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

@@ -35,6 +35,7 @@ public:
     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);
+    void removeServiceBooking(const std::string& bookingID);
     util::Map<std::string, JobCard*> getJobCards(const std::string& technicianID);
     void updateJobStatus(const std::string& jobID);
     void cancelCustomerServiceBookings(const std::string& customerID);

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

@@ -163,7 +163,13 @@ Return type: void
 void AdminMenu::handleNotificationEvent()
 {
 	auto notifications = m_controller.getNotifications();
-	displayNewNotification(notifications);
+	const User* authenticatedUser = m_controller.getAuthenticatedUser();
+	std::string name;
+	if (authenticatedUser)
+	{
+		name = authenticatedUser->getName();
+	}
+	displayNewNotification(notifications, name);
 }
 
 /*
@@ -332,6 +338,23 @@ void AdminMenu::removeInventoryItem()
             std::string selectedItemId = selectedItem->getId();
             m_controller.removeInventoryItem(selectedItemId);
             std::cout << "Item " << selectedItem->getPartName() << " removed successfully." << std::endl;
+			const util::Map<std::string, const Service*>& listOfService = m_controller.getServices();
+			for (int serviceIndex = 0; serviceIndex < listOfService.getSize(); serviceIndex++)
+			{
+				const Service* service = listOfService.getValueAt(serviceIndex);
+				if (!service)
+				{
+					continue;
+				}
+				const util::Map<std::string, InventoryItem*>& requiredItems = service->getRequiredInventoryItems();
+				if (requiredItems.find(selectedItemId) != -1) 
+				{
+					m_controller.removeService(service->getId()); 
+					std::cout << "Service " << service->getName()
+						<< " removed as the item "
+						<< selectedItem->getPartName() << " required for the service has been removed." << std::endl;
+				}
+			}
         }
     }
     util::pressEnter();

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

@@ -51,11 +51,12 @@ void CustomerMenu::showMenu()
                 << "\n3. Update Profile"
                 << "\n4. Change Password"
                 << "\n5. View Service History"
-                << "\n6. Complete Payments"
-                << "\n7. View Invoices"
-                << "\n8. View Notifications"
-                << "\n9. Configure Notifications"
-                << "\n10. Logout"
+                << "\n6. Cancel Service Booking"
+                << "\n7. Complete Payments"
+                << "\n8. View Invoices"
+                << "\n9. View Notifications"
+                << "\n10. Configure Notifications"
+                << "\n11. Logout"
                 << "\nEnter a choice: ";
             util::read(choice);
             if (!handleOperation(choice))
@@ -103,18 +104,21 @@ bool CustomerMenu::handleOperation(int choice)
         viewServiceHistory();
         break;
     case 6:
-        completePayments();
+        cancelServiceBooking();
         break;
     case 7:
-        viewInvoices();
+        completePayments();
         break;
     case 8:
-        viewNotifications();
+        viewInvoices();
         break;
     case 9:
-        configureNotifications();
+        viewNotifications();
         break;
     case 10:
+        configureNotifications();
+        break;
+    case 11:
         logout();
         return false;
     default:
@@ -134,7 +138,13 @@ Return type: void
 void CustomerMenu::handleNotificationEvent()
 {
     auto notifications = m_controller.getNotifications();
-    displayNewNotification(notifications);
+    const User* authenticatedUser = m_controller.getAuthenticatedUser();
+    std::string name;
+    if (authenticatedUser)
+    {
+        name = authenticatedUser->getName();
+    }
+    displayNewNotification(notifications, name);
 }
 
 /*
@@ -210,6 +220,13 @@ void CustomerMenu::selectService()
         util::pressEnter();
         return;
     }
+    if (!verifyAllPaymentsCompleted(m_controller))
+    {
+        std::cout << "Your booking cannot be processed because you have pending payments for previous services. Please complete all outstanding invoices before booking a new service."
+             << std::endl;
+        util::pressEnter();
+        return;
+    }
     util::Vector<std::string> selectedServices;
     const Service* selectedService = selectServiceFromServices(services);
     if (selectedService == nullptr)
@@ -252,6 +269,13 @@ void CustomerMenu::selectComboPackage()
         util::pressEnter();
         return;
     }
+    if (!verifyAllPaymentsCompleted(m_controller))
+    {
+        std::cout << "Your booking cannot be processed because you have pending payments for previous services. Please complete all outstanding invoices before booking a new combo package."
+            << std::endl;
+        util::pressEnter();
+        return;
+    }
     const ComboPackage* selectedComboPackage = selectComboPackageFromPackages(activeComboPackages);
     if (selectedComboPackage == nullptr)
     {
@@ -327,6 +351,46 @@ void CustomerMenu::viewServiceHistory()
     util::pressEnter();
 }
 
+/*
+Function: cancelServiceBooking
+Description: Allows the customer to cancel a pending service booking.
+             Displays the list of active bookings, lets the user select one,
+             and removes it from the system. If no bookings are available,
+             an appropriate message is shown.
+Parameter: None
+Return type: void
+*/
+void CustomerMenu::cancelServiceBooking()
+{
+    util::clear();
+    std::cout << "Cancel Service Booking\n";
+    const User* currentUser = m_controller.getAuthenticatedUser();
+    std::string currentUserID = currentUser->getId();
+    util::Map<std::string, const ServiceBooking*> serviceBookingsByCurrentUser = m_controller.getServiceBookingsByUser(currentUserID);
+    util::Map<int, const ServiceBooking*> serviceBookingsMap;
+    auto currentPendingServiceBookings = filterActiveServiceBookings(serviceBookingsByCurrentUser);
+    int bookingsSize = currentPendingServiceBookings.getSize();
+    if (listServiceBookings(currentPendingServiceBookings, bookingsSize, serviceBookingsMap))
+    {
+        const ServiceBooking* selectedService = selectPendingServiceBookings(serviceBookingsMap);
+        if (selectedService)
+        {
+            m_controller.removeServiceBooking(selectedService->getId());
+            std::cout << "Cancelled Service booking of id " + selectedService->getId() << std::endl << std::endl;
+        }
+        else
+        {
+            std::cout << "Invalid service booking index.\n\n";
+            return;
+        }
+    }
+    else
+    {
+        std::cout << "No pending service bookings available.\n\n";
+    }
+    util::pressEnter();
+}
+
 /*
 Function: completePayments
 Description: Allows the customer to complete pending payments for invoices.

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

@@ -28,5 +28,6 @@ public:
     void completePayments();
     void viewInvoices();
     void viewNotifications();
+    void cancelServiceBooking();
     void configureNotifications();
-};
+};

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/Menu.cpp

@@ -133,10 +133,16 @@ Return type: void
 void Menu::handleAccountDisabledEvent()
 {
     m_isMenuActive.store(false);
+    const User* authenticatedUser = m_controller.getAuthenticatedUser();
+    std::string messageTitle = "Account Disabled";
+    if (authenticatedUser)
+    {
+        messageTitle += " - " + authenticatedUser->getName();
+    }
     MessageBoxA(
         GetConsoleWindow(),
         "Your account has been disabled.",
-        "Account Disabled",
+        messageTitle.c_str(),
         MB_OK |
         MB_ICONWARNING |
         MB_SETFOREGROUND |

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

@@ -28,6 +28,7 @@ Date: 21-May-2026
 #include "Utility.h"
 #include "Validator.h"
 #include "Vector.h"
+#include "StringHelper.h"
 
 /*
 Function: displayAllServices
@@ -1056,6 +1057,21 @@ inline const Service* selectServiceFromServices(const util::Map<std::string, con
         {
             continue;
         }
+        bool hasDepletedItem = false;
+        const util::Map<std::string, InventoryItem*>& requiredItems = currentService->getRequiredInventoryItems();
+        for (int itemIndex = 0; itemIndex < requiredItems.getSize(); itemIndex++)
+        {
+            const InventoryItem* item = requiredItems.getValueAt(itemIndex);
+            if (!item || item->getQuantity() < 1)
+            {
+                hasDepletedItem = true;
+                break;
+            }
+        }
+        if (hasDepletedItem)
+        {
+            continue; 
+        }
         activeServicesMap.insert(currentIndex, currentService);
         double partsCost = util::calculatePartsCost(currentService);
         std::cout << std::left
@@ -1415,9 +1431,10 @@ Description: Displays the most recent notification from the supplied
              notification collection.
 Parameter: util::Vector<const Notification*> notifications -
            collection of notifications
+           const std::string& - The name of the user currently authenticated with the system
 Return type: void
 */
-inline void displayNewNotification(util::Vector<const Notification*> notifications)
+inline void displayNewNotification(util::Vector<const Notification*> notifications, const std::string& name)
 {
     const Notification* notification = nullptr;
 	size_t numberOfNotifications = notifications.getSize();
@@ -1429,16 +1446,66 @@ inline void displayNewNotification(util::Vector<const Notification*> notificatio
 		}
 		else
 		{
-			if (notification->getId() < notifications[index]->getId())
+            if (util::extractNumber(notification->getId()) < util::extractNumber(notifications[index]->getId()))
 			{
 				notification = notifications[index];
 			}
 		}
 	}
-    MessageBoxA(
-        GetConsoleWindow(),
-        notification->getMessage().c_str(),
-        notification->getTitle().c_str(),
-        MB_OK |
-        MB_ICONINFORMATION);
-}
+    if (notification)
+    {
+        std::string messageTitle = notification->getTitle();
+        if (!name.empty())
+        {
+            messageTitle += " - " + name;
+        }
+        MessageBoxA(
+            GetConsoleWindow(),
+            notification->getMessage().c_str(),
+            messageTitle.c_str(),
+            MB_OK |
+            MB_ICONINFORMATION);
+    }
+}
+
+/*
+Function: verifyAllPaymentsCompleted
+Description: Checks whether the authenticated customer has completed
+             all payments for their invoices. Iterates through all
+             invoices belonging to the customer and verifies that
+             each invoice has a payment status of COMPLETED.
+Parameters: Controller& m_controller -
+            reference to the Controller object used to access
+            authenticated user and invoice data
+Return type: bool
+             true if all invoices for the authenticated customer
+             are completed, false if any invoice is pending or not completed
+Throws: std::runtime_error if no authenticated user is found
+*/
+inline bool verifyAllPaymentsCompleted(Controller& m_controller)
+{
+    const User* authenticatedUser = m_controller.getAuthenticatedUser();
+    if (!authenticatedUser)
+    {
+        throw std::runtime_error("No authenticated user found.");
+    }
+    const std::string& authenticatedUserId = authenticatedUser->getId();
+    util::Map<std::string, const Invoice*> listOfInvoices = m_controller.getAllInvoices();
+    for (int invoiceIndex = 0; invoiceIndex < listOfInvoices.getSize(); ++invoiceIndex)
+    {
+        const Invoice* invoice = listOfInvoices.getValueAt(invoiceIndex);
+        if (!invoice)
+        {
+            continue;
+        }
+        const std::string& customerId = invoice->getBooking()->getCustomerId();
+        if (customerId == authenticatedUserId)
+        {
+            if (invoice->getStatus() != util::PaymentStatus::COMPLETED)
+            {
+                return false;
+            }
+        }
+    }
+    return true;
+}

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

@@ -108,7 +108,13 @@ Return type: void
 void TechnicianMenu::handleNotificationEvent()
 {
     auto notifications = m_controller.getNotifications();
-    displayNewNotification(notifications);
+    const User* authenticatedUser = m_controller.getAuthenticatedUser();
+    std::string name;
+    if (authenticatedUser)
+    {
+        name = authenticatedUser->getName();
+    }
+    displayNewNotification(notifications, name);
 }
 
 /*