Notify admins when new service bookings are created

Changes:
- Added notifyAllAdmins() helper in ServiceManagementService.
- Sent notifications to all administrators when a customer places a service booking.
- Sent notifications to all administrators when a customer purchases a combo package.
- Included the generated Service Booking ID in admin notifications.

Fixes #2100

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

@@ -102,7 +102,7 @@
       <SDLCheck>true</SDLCheck>
       <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
-      <AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)factories;$(ProjectDir)views;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)core\patterns;$(ProjectDir)datastores;$(ProjectDir)datastores\sharedmemory;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)factories;$(ProjectDir)views;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)core\patterns;$(ProjectDir)datastores;$(ProjectDir)core\sharedmemory;$(ProjectDir)core\events;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -117,7 +117,7 @@
       <SDLCheck>true</SDLCheck>
       <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
-      <AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)factories;$(ProjectDir)views;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)core\patterns;$(ProjectDir)datastores;$(ProjectDir)datastores\sharedmemory;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)factories;$(ProjectDir)views;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)core\patterns;$(ProjectDir)datastores;$(ProjectDir)core\sharedmemory;$(ProjectDir)core\events;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -126,10 +126,11 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="controllers\Controller.cpp" />
+    <ClCompile Include="core\events\EventManager.cpp" />
     <ClCompile Include="core\patterns\Observer.cpp" />
     <ClCompile Include="core\patterns\Subject.cpp" />
+    <ClCompile Include="core\sharedmemory\SharedMemory.cpp" />
     <ClCompile Include="datastores\DataStore.cpp" />
-    <ClCompile Include="datastores\sharedmemory\SharedMemory.cpp" />
     <ClCompile Include="models\ComboPackage.cpp" />
     <ClCompile Include="models\InventoryItem.cpp" />
     <ClCompile Include="models\Invoice.cpp" />
@@ -148,21 +149,23 @@
     <ClCompile Include="utilities\Validator.cpp" />
     <ClCompile Include="views\AdminMenu.cpp" />
     <ClCompile Include="views\CustomerMenu.cpp" />
+    <ClCompile Include="views\Menu.cpp" />
     <ClCompile Include="views\TechnicianMenu.cpp" />
     <ClCompile Include="views\UserInterface.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="controllers\Controller.h" />
+    <ClInclude Include="core\events\EventManager.h" />
     <ClInclude Include="core\patterns\Observer.h" />
     <ClInclude Include="core\patterns\Subject.h" />
+    <ClInclude Include="core\sharedmemory\FileHeader.h" />
+    <ClInclude Include="core\sharedmemory\MappingInfo.h" />
+    <ClInclude Include="core\sharedmemory\RecordState.h" />
+    <ClInclude Include="core\sharedmemory\SerializedRecords.h" />
+    <ClInclude Include="core\sharedmemory\SharedMemory.h" />
+    <ClInclude Include="core\sharedmemory\TrackedRecord.h" />
     <ClInclude Include="datastores\DataStore.h" />
     <ClInclude Include="datastores\DataStoreLockGuard.h" />
-    <ClInclude Include="datastores\sharedmemory\FileHeader.h" />
-    <ClInclude Include="datastores\sharedmemory\MappingInfo.h" />
-    <ClInclude Include="datastores\sharedmemory\RecordState.h" />
-    <ClInclude Include="datastores\sharedmemory\SerializedRecords.h" />
-    <ClInclude Include="datastores\sharedmemory\SharedMemory.h" />
-    <ClInclude Include="datastores\sharedmemory\TrackedRecord.h" />
     <ClInclude Include="factories\Factory.h" />
     <ClInclude Include="models\ComboPackage.h" />
     <ClInclude Include="models\InventoryItem.h" />
@@ -191,6 +194,7 @@
     <ClInclude Include="utilities\Vector.h" />
     <ClInclude Include="views\AdminMenu.h" />
     <ClInclude Include="views\CustomerMenu.h" />
+    <ClInclude Include="views\Menu.h" />
     <ClInclude Include="views\MenuHelper.h" />
     <ClInclude Include="views\TechnicianMenu.h" />
     <ClInclude Include="views\UserInterface.h" />

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

@@ -64,11 +64,17 @@
     <Filter Include="Source Files\Core\Patterns">
       <UniqueIdentifier>{8057b93d-51a9-42df-b06e-01ce395f6308}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Header Files\DataStores\SharedMemory">
-      <UniqueIdentifier>{ec639004-44c6-4bd6-9963-077adde82b5f}</UniqueIdentifier>
+    <Filter Include="Header Files\Core\SharedMemory">
+      <UniqueIdentifier>{d9da9793-fe6f-4914-bee3-99d5934da228}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Source Files\DataStores\SharedMemory">
-      <UniqueIdentifier>{7aa8722e-adfa-466e-8211-de63f3b7892b}</UniqueIdentifier>
+    <Filter Include="Source Files\Core\SharedMemory">
+      <UniqueIdentifier>{0769afb6-f57d-4ae3-a1cf-ceca6e606af0}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\Core\Events">
+      <UniqueIdentifier>{85029bdb-6941-41dc-a3a7-9e5841671d8c}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Core\Events">
+      <UniqueIdentifier>{1050aca7-6f2c-4ccb-a446-db9c898c3599}</UniqueIdentifier>
     </Filter>
   </ItemGroup>
   <ItemGroup>
@@ -144,8 +150,14 @@
     <ClCompile Include="models\ComboPackage.cpp">
       <Filter>Source Files\Models</Filter>
     </ClCompile>
-    <ClCompile Include="datastores\sharedmemory\SharedMemory.cpp">
-      <Filter>Source Files\DataStores\SharedMemory</Filter>
+    <ClCompile Include="core\sharedmemory\SharedMemory.cpp">
+      <Filter>Source Files\Core\SharedMemory</Filter>
+    </ClCompile>
+    <ClCompile Include="core\events\EventManager.cpp">
+      <Filter>Source Files\Core\Events</Filter>
+    </ClCompile>
+    <ClCompile Include="views\Menu.cpp">
+      <Filter>Source Files\Views</Filter>
     </ClCompile>
   </ItemGroup>
   <ItemGroup>
@@ -254,26 +266,32 @@
     <ClInclude Include="views\MenuHelper.h">
       <Filter>Header Files\Views</Filter>
     </ClInclude>
-    <ClInclude Include="datastores\sharedmemory\FileHeader.h">
-      <Filter>Header Files\DataStores\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="datastores\sharedmemory\MappingInfo.h">
-      <Filter>Header Files\DataStores\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="datastores\sharedmemory\RecordState.h">
-      <Filter>Header Files\DataStores\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="datastores\sharedmemory\TrackedRecord.h">
-      <Filter>Header Files\DataStores\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="datastores\sharedmemory\SerializedRecords.h">
-      <Filter>Header Files\DataStores\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="datastores\sharedmemory\SharedMemory.h">
-      <Filter>Header Files\DataStores\SharedMemory</Filter>
-    </ClInclude>
     <ClInclude Include="datastores\DataStoreLockGuard.h">
       <Filter>Header Files\DataStores</Filter>
     </ClInclude>
+    <ClInclude Include="core\sharedmemory\FileHeader.h">
+      <Filter>Header Files\Core\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="core\sharedmemory\MappingInfo.h">
+      <Filter>Header Files\Core\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="core\sharedmemory\RecordState.h">
+      <Filter>Header Files\Core\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="core\sharedmemory\SerializedRecords.h">
+      <Filter>Header Files\Core\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="core\sharedmemory\SharedMemory.h">
+      <Filter>Header Files\Core\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="core\sharedmemory\TrackedRecord.h">
+      <Filter>Header Files\Core\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="core\events\EventManager.h">
+      <Filter>Header Files\Core\Events</Filter>
+    </ClInclude>
+    <ClInclude Include="views\Menu.h">
+      <Filter>Header Files\Views</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

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

@@ -622,3 +622,16 @@ void Controller::shutdown()
     auto& dataStore = DataStore::getInstance();
     dataStore.shutdown();
 }
+
+/*
+Function: registerEvents
+Description: Registers menu event handles with the authentication
+             service.
+Parameter: HANDLE accountDisabledEvent - account disabled event handle
+           HANDLE notificationAvailableEvent - notification event handle
+Return type: void
+*/
+void Controller::registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent)
+{
+    m_authenticationManagementService.registerEvents(accountDisabledEvent, notificationAvailableEvent);
+}

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

@@ -8,6 +8,7 @@ Date:19-May-2026
 */
 
 #pragma once
+#include <windows.h>
 #include <string>
 #include "AuthenticationManagementService.h"
 #include "Enums.h"
@@ -72,4 +73,5 @@ public:
     void configureNotifications(bool paymentNotifications, bool serviceNotifications);
     bool initialize();
     void shutdown();
+    void registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent);
 };

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/core/events/EventManager.cpp

@@ -0,0 +1,225 @@
+/*
+File: EventManager.cpp
+Description: Implementation file containing the method definitions of the
+             EventManager class, including listener management and
+             interprocess event publishing.
+Author: Trenser
+Date:15-Jun-2026
+*/
+
+#include <iostream>
+#include <stdexcept>
+#include "EventManager.h"
+
+namespace
+{
+    const std::string USER_DISABLED_EVENT = "userDisabled_";
+
+    const std::string NOTIFICATION_AVAILABLE_EVENT = "notificationAvailable_";
+}
+
+/*
+Function: EventManager
+Description: Constructs an EventManager instance with default values.
+Parameter: None
+Return type: None
+*/
+EventManager::EventManager()
+    :
+    m_userDisabledEvent(NULL),
+    m_notificationAvailableEvent(NULL),
+    m_shutdownEvent(NULL),
+    m_running(false) {}
+
+/*
+Function: ~EventManager
+Description: Destroys the EventManager and performs final cleanup.
+Parameter: None
+Return type: None
+*/
+EventManager::~EventManager()
+{
+    shutdown();
+    if (m_listenerThread.joinable())
+    {
+        m_listenerThread.join();
+    }
+}
+
+/*
+Function: initialize
+Description: Creates the user-specific events and starts the listener
+             thread.
+Parameter: const std::string& userId - unique identifier of the user
+           std::function<void()> userDisabledCallback - callback for
+           user disable events
+           std::function<void()> notificationCallback - callback for
+           notification events
+Return type: bool - true if initialization succeeds, false otherwise
+*/
+bool EventManager::initialize(const std::string& userId, std::function<void()> userDisabledCallback, std::function<void()> notificationCallback)
+{
+    if (m_running.load())
+    {
+        return false;
+    }
+    m_userDisabledCallback = userDisabledCallback;
+    m_notificationCallback = notificationCallback;
+    m_userDisabledEvent = CreateEventA(NULL, FALSE, FALSE, (USER_DISABLED_EVENT + userId).c_str());
+    if (!m_userDisabledEvent)
+    {
+        return false;
+    }
+    if (GetLastError() == ERROR_ALREADY_EXISTS)
+    {
+        CloseHandle(m_userDisabledEvent);
+        m_userDisabledEvent = NULL;
+        throw std::runtime_error("Only one session allowed per user.");
+    }
+    m_notificationAvailableEvent = CreateEventA(NULL, FALSE, FALSE, (NOTIFICATION_AVAILABLE_EVENT + userId).c_str());
+    if (!m_notificationAvailableEvent)
+    {
+        CloseHandle(m_userDisabledEvent);
+        m_userDisabledEvent = NULL;
+        return false;
+    }
+    m_shutdownEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
+    if (!m_shutdownEvent)
+    {
+        CloseHandle(m_userDisabledEvent);
+        CloseHandle(m_notificationAvailableEvent);
+        m_userDisabledEvent = NULL;
+        m_notificationAvailableEvent = NULL;
+        return false;
+    }
+    m_running.store(true);
+    m_listenerThread = std::thread(&EventManager::run, this);
+    return true;
+}
+
+/*
+Function: shutdown
+Description: Stops the listener thread and releases event resources.
+Parameter: None
+Return type: None
+*/
+void EventManager::shutdown()
+{
+    if (!m_running.load())
+    {
+        return;
+    }
+    m_running.store(false);
+    if (m_shutdownEvent)
+    {
+        SetEvent(m_shutdownEvent);
+    }
+    if (m_listenerThread.joinable())
+    {
+        if (std::this_thread::get_id() != m_listenerThread.get_id())
+        {
+            m_listenerThread.join();
+        }
+    }
+    if (m_userDisabledEvent)
+    {
+        CloseHandle(m_userDisabledEvent);
+        m_userDisabledEvent = NULL;
+    }
+    if (m_notificationAvailableEvent)
+    {
+        CloseHandle(m_notificationAvailableEvent);
+        m_notificationAvailableEvent = NULL;
+    }
+    if (m_shutdownEvent)
+    {
+        CloseHandle(m_shutdownEvent);
+        m_shutdownEvent = NULL;
+    }
+}
+
+/*
+Function: run
+Description: Waits for and dispatches user-related events.
+Parameter: None
+Return type: void
+*/
+void EventManager::run()
+{
+    HANDLE handles[3];
+    handles[0] = m_userDisabledEvent;
+    handles[1] = m_notificationAvailableEvent;
+    handles[2] = m_shutdownEvent;
+    while (m_running.load())
+    {
+        DWORD result = WaitForMultipleObjects(3, handles, FALSE, INFINITE);
+        switch (result)
+        {
+        case WAIT_OBJECT_0:
+            try
+            {
+                if (m_userDisabledCallback)
+                {
+                    m_userDisabledCallback();
+                }
+            }
+            catch (const std::exception& exception)
+            {
+                std::cout << exception.what() << std::endl;
+            }
+            break;
+        case WAIT_OBJECT_0 + 1:
+            try
+            {
+                if (m_notificationCallback)
+                {
+                    m_notificationCallback();
+                }
+            }
+            catch (const std::exception& exception)
+            {
+                std::cout << exception.what() << std::endl;
+            }
+            break;
+        case WAIT_OBJECT_0 + 2:
+            return;
+        default:
+            break;
+        }
+    }
+}
+
+/*
+Function: sendUserDisabledEvent
+Description: Publishes a user disabled event for a specific user.
+Parameter: const std::string& userId - target user identifier
+Return type: void
+*/
+void EventManager::sendUserDisabledEvent(const std::string& userId)
+{
+    HANDLE eventHandle = CreateEventA(NULL, FALSE, FALSE, (USER_DISABLED_EVENT + userId).c_str());
+    if (!eventHandle)
+    {
+        return;
+    }
+    SetEvent(eventHandle);
+    CloseHandle(eventHandle);
+}
+
+/*
+Function: sendNotificationAvailableEvent
+Description: Publishes a notification available event for a specific
+             user.
+Parameter: const std::string& userId - target user identifier
+Return type: void
+*/
+void EventManager::sendNotificationAvailableEvent(const std::string& userId)
+{
+    HANDLE eventHandle = CreateEventA(NULL, FALSE, FALSE, (NOTIFICATION_AVAILABLE_EVENT + userId).c_str());
+    if (!eventHandle)
+    {
+        return;
+    }
+    SetEvent(eventHandle);
+    CloseHandle(eventHandle);
+}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/core/events/EventManager.h

@@ -0,0 +1,37 @@
+/*
+File: EventManager.h
+Description: Header file declaring the EventManager class, which manages
+             user-specific interprocess events for user disable and
+             notification availability updates.
+Author: Trenser
+Date:15-Jun-2026
+*/
+
+#pragma once
+
+#include <windows.h>
+#include <atomic>
+#include <functional>
+#include <string>
+#include <thread>
+
+class EventManager
+{
+private:
+    HANDLE m_userDisabledEvent;
+    HANDLE m_notificationAvailableEvent;
+    HANDLE m_shutdownEvent;
+    std::atomic<bool> m_running;
+    std::thread m_listenerThread;
+    std::function<void()> m_userDisabledCallback;
+    std::function<void()> m_notificationCallback;
+    void run();
+
+public:
+    EventManager();
+    ~EventManager();
+    bool initialize(const std::string& userId, std::function<void()> userDisabledCallback, std::function<void()> notificationCallback);
+    void shutdown();
+    static void sendUserDisabledEvent(const std::string& userId);
+    static void sendNotificationAvailableEvent(const std::string& userId);
+};

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

@@ -14,6 +14,7 @@ Date: 19-May-2026
 #include "FileHelper.h"
 #include "ServiceBooking.h"
 #include "JobCard.h"
+#include "Invoice.h"
 
 /*
 Function: DataStore
@@ -450,6 +451,45 @@ Returns:
 */
 util::Map<std::string, TrackedRecord<Invoice>>& DataStore::getInvoices()
 {
+    auto& serviceBookings = getServiceBookings();
+    auto& inventoryItems = getInventoryItems();
+    util::Map<std::string, TrackedRecord<Invoice>> invoices = loadRecords<Invoice, SerializedInvoice>(m_invoices);
+    refreshCache(m_invoiceCache, invoices);
+    for (int iterator = 0; iterator < m_invoiceCache.getSize(); iterator++)
+    {
+        auto& trackedInvoice = m_invoiceCache.getValueAt(iterator);
+        Invoice* invoice = trackedInvoice.data;
+        if (!invoice)
+        {
+            continue;
+        }
+        const std::string& currentBookingId = invoice->getBookingId();
+        int currentBookingIndex = serviceBookings.find(currentBookingId);
+        if (currentBookingIndex == -1)
+        {
+            throw std::runtime_error("Invalid Service Booking Index.");
+        }
+        ServiceBooking* currentBooking = serviceBookings.getValueAt(currentBookingIndex).data;
+        auto& currentInventoryItemIds = invoice->getPartIDs();
+        util::Map<std::string, InventoryItem*> currentInventoryItems;
+        for (int iterator = 0; iterator < currentInventoryItemIds.getSize(); iterator++)
+        {
+            const std::string& currentItemId = currentInventoryItemIds[iterator];
+            int currentItemIndex = inventoryItems.find(currentItemId);
+            if (currentItemIndex == -1)
+            {
+                throw std::runtime_error("Invalid Inventory item id.");
+            }
+            InventoryItem* currentItem = inventoryItems.getValueAt(currentItemIndex).data;
+            if (!currentItem)
+            {
+                continue;
+            }
+            currentInventoryItems[currentItemId] = currentItem;
+        }
+        invoice->setBooking(currentBooking);
+        invoice->setParts(currentInventoryItems);
+    }
     return m_invoiceCache;
 }
 
@@ -624,6 +664,7 @@ Returns:
 */
 void DataStore::saveInvoices()
 {
+    saveRecords<Invoice, SerializedInvoice>(m_invoices, m_invoiceCache);
 }
 
 /*
@@ -740,4 +781,3 @@ bool DataStore::unlockDataStore()
     }
     return ReleaseMutex(m_globalMutex) != 0;
 }
-

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

@@ -220,6 +220,12 @@ void DataStore::refreshCache(util::Map<std::string, TrackedRecord<TObject>>& cac
         if (oldIndex != -1)
         {
             TrackedRecord<TObject>& oldRecord = oldCache.getValueAt(oldIndex);
+            if (oldRecord.state == RecordState::MODIFIED)
+            {
+                delete refreshedRecord.data;
+                cache.insert(id, oldRecord);
+                continue;
+            }
             *oldRecord.data = *refreshedRecord.data;
             oldRecord.slotIndex = refreshedRecord.slotIndex;
             oldRecord.state = refreshedRecord.state;

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

@@ -9,6 +9,7 @@ Date: 19-May-2026
 
 #include <sstream>
 #include <stdexcept>
+#include "SerializedRecords.h"
 #include "Invoice.h"
 #include "Factory.h"
 #include "InventoryItem.h"
@@ -34,7 +35,8 @@ Invoice::Invoice()
     m_discountPercentage(0.0),
     m_totalAmount(0.0),
     m_paymentMethod(util::PaymentMode()),
-    m_status(util::PaymentStatus()) {}
+    m_status(util::PaymentStatus()) {
+}
 
 /*
 Function: Invoice
@@ -66,7 +68,7 @@ Invoice::Invoice(
     const util::Timestamp& paymentDate,
     util::PaymentMode paymentMethod,
     util::PaymentStatus status
-    )
+)
     : m_id("INV" + std::to_string(++m_uid)),
     m_bookingId(bookingId),
     m_booking(booking),
@@ -473,100 +475,50 @@ static util::Vector<std::string> getPartIDsAsVector(const std::string& partIDsSt
 
 /*
 Function: serialize
-Description: Serializes the invoice into a CSV-formatted string.
+Description: Serializes the Invoice object into a SerializedInvoice record.
 Parameters:
     - None
 Returns:
-    - std::string: Serialized invoice record
+    - SerializedInvoice: Serialized representation of the invoice
 */
-std::string Invoice::serialize() const
+SerializedInvoice Invoice::serialize() const
 {
-    std::ostringstream serializedInvoice;
-    serializedInvoice << m_id << ','
-        << m_bookingId << ','
-        << m_invoiceDate.toString() << ','
-        << m_laborCost << ','
-        << getPartIDsAsString(m_partIDs) << ','
-        << m_partsCost << ','
-        << m_discountPercentage << ','
-        << m_totalAmount << ','
-        << m_paymentDate.toString() << ','
-        << util::getPaymentModeString(m_paymentMethod) << ','
-        << util::getPaymentStatusString(m_status);
-    return serializedInvoice.str();
+    SerializedInvoice serialized = {};
+    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
+    strcpy_s(serialized.bookingId, sizeof(serialized.bookingId), m_bookingId.c_str());
+    strcpy_s(serialized.partIDs, sizeof(serialized.partIDs), getPartIDsAsString(m_partIDs).c_str());
+    serialized.invoiceDate = m_invoiceDate;
+    serialized.laborCost = m_laborCost;
+    serialized.partsCost = m_partsCost;
+    serialized.discountPercentage = m_discountPercentage;
+    serialized.totalAmount = m_totalAmount;
+    serialized.paymentDate = m_paymentDate;
+    serialized.paymentMethod = m_paymentMethod;
+    serialized.status = m_status;
+    return serialized;
 }
 
 /*
 Function: deserialize
-Description: Deserializes a CSV-formatted string into an Invoice object.
+Description: Deserializes a SerializedInvoice record into an Invoice object.
 Parameters:
-    - record: const std::string&, serialized invoice record
+    - serializedInvoice: const SerializedInvoice&, 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)
+Invoice* Invoice::deserialize(const SerializedInvoice& serializedInvoice)
 {
-    std::string id, bookingId;
-    std::string invoiceDateString, laborCostString, partIDsString;
-    std::string partsCostString, discountPercentageString, totalAmountString;
-    std::string paymentDateString, paymentMethodString, statusString;
-    double laborCost, partsCost, discountPercentage, totalAmount;
-    std::istringstream serializedInvoice(record);
-    getline(serializedInvoice, id, ',');
-    getline(serializedInvoice, bookingId, ',');
-    getline(serializedInvoice, invoiceDateString, ',');
-    getline(serializedInvoice, laborCostString, ',');
-    getline(serializedInvoice, partIDsString, ',');
-    getline(serializedInvoice, partsCostString, ',');
-    getline(serializedInvoice, discountPercentageString, ',');
-    getline(serializedInvoice, totalAmountString, ',');
-    getline(serializedInvoice, paymentDateString, ',');
-    getline(serializedInvoice, paymentMethodString, ',');
-    getline(serializedInvoice, statusString, ',');
-    util::Timestamp invoiceDate;
-    util::Timestamp paymentDate;
-    try
-    {
-        invoiceDate = util::Timestamp::fromString(invoiceDateString);
-        paymentDate = util::Timestamp::fromString(paymentDateString);
-        laborCost = std::stod(laborCostString);
-        partsCost = std::stod(partsCostString);
-        discountPercentage = std::stod(discountPercentageString);
-        totalAmount = std::stod(totalAmountString);
-    }
-    catch (...)
-    {
-        throw std::runtime_error("Invalid invoice data");
-    }
-    util::Vector<std::string> partIDs = getPartIDsAsVector(partIDsString);
-    util::PaymentMode paymentMethod = util::getPaymentMode(paymentMethodString);
-    util::PaymentStatus status = util::getPaymentStatus(statusString);
+    util::Vector<std::string> partIDs = getPartIDsAsVector(serializedInvoice.partIDs);
     return Factory::getObject<Invoice>(
-        id,
-        bookingId,
-        invoiceDate,
+        serializedInvoice.id,
+        serializedInvoice.bookingId,
+        serializedInvoice.invoiceDate,
         partIDs,
-        laborCost,
-        partsCost,
-        discountPercentage,
-        totalAmount,
-        paymentDate,
-        paymentMethod,
-        status
-    );
-}
-
-/*
-Function: getHeaders
-Description: Retrieves the CSV headers for invoice serialization.
-Parameters:
-    - None
-Returns:
-    - std::string: Header string ("ID,BookingID,InvoiceDate,LaborCost,PartIDs,PartsCost,DiscountPercentage,TotalAmount,PaymentDate,PaymentMethod,Status")
-*/
-std::string Invoice::getHeaders()
-{
-    return "ID,BookingID,InvoiceDate,LaborCost,PartIDs,PartsCost,DiscountPercentage,TotalAmount,PaymentDate,PaymentMethod,Status";
+        serializedInvoice.laborCost,
+        serializedInvoice.partsCost,
+        serializedInvoice.discountPercentage,
+        serializedInvoice.totalAmount,
+        serializedInvoice.paymentDate,
+        serializedInvoice.paymentMethod,
+        serializedInvoice.status);
 }

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

@@ -6,7 +6,6 @@ Author: Trenser
 Date: 19-May-2026
 */
 
-
 #pragma once
 #include <string>
 #include "Map.h"
@@ -16,6 +15,7 @@ Date: 19-May-2026
 
 class ServiceBooking;
 class InventoryItem;
+struct SerializedInvoice;
 
 class Invoice
 {
@@ -41,7 +41,7 @@ public:
         ServiceBooking* booking,
         const util::Timestamp& invoiceDate,
         double laborCost,
-        const util::Map<std::string,InventoryItem*>& parts,
+        const util::Map<std::string, InventoryItem*>& parts,
         double partsCost,
         double discountPercentage,
         double totalAmount,
@@ -87,7 +87,6 @@ public:
     void setPaymentDate(const util::Timestamp& paymentDate);
     void setPaymentMethod(util::PaymentMode paymentMethod);
     void setStatus(util::PaymentStatus status);
-    std::string serialize() const;
-    static Invoice* deserialize(const std::string&);
-    static std::string getHeaders();
+    SerializedInvoice serialize() const;
+    static Invoice* deserialize(const SerializedInvoice&);
 };

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

@@ -14,6 +14,28 @@ Date:19-May-2026
 #include "DataStoreLockGuard.h"
 
 User* AuthenticationManagementService::m_authenticatedUser = nullptr;
+bool AuthenticationManagementService::m_isAuthorized = false;
+EventManager AuthenticationManagementService::m_eventManager;
+HANDLE AuthenticationManagementService::m_accountDisabledEvent = NULL;
+HANDLE AuthenticationManagementService::m_notificationsAvailableEvent = NULL;
+
+
+/*
+Function: ensureAuthorization
+Description: Verifies that a user is currently authenticated before allowing
+			 access to a protected operation. Throws an exception if no
+			 authorized user session exists.
+Parameter: None
+Return type: void
+Throws: std::runtime_error - if the user is not authorized
+*/
+void AuthenticationManagementService::ensureAuthorization()
+{
+	if (!m_authenticatedUser || !m_isAuthorized)
+	{
+		throw std::runtime_error("You are not authorized to do this operation!");
+	}
+}
 
 /*
 Function: login
@@ -37,6 +59,24 @@ bool AuthenticationManagementService::login(const std::string& username, const s
 			if (password == user->getPassword())
 			{
 				m_authenticatedUser = user;
+				m_isAuthorized = true;
+				m_eventManager.initialize(
+					user->getId(),
+					[]()
+					{
+						if (m_accountDisabledEvent)
+						{
+							AuthenticationManagementService::m_isAuthorized = false;
+							SetEvent(m_accountDisabledEvent);
+						}
+					},
+					[]()
+					{
+						if (m_notificationsAvailableEvent)
+						{
+							SetEvent(m_notificationsAvailableEvent);
+						}
+					});
 				return true;
 			}
 			return false;
@@ -65,7 +105,11 @@ Return type: void
 */
 void AuthenticationManagementService::logout()
 {
+	m_eventManager.shutdown();
 	m_authenticatedUser = nullptr;
+	m_isAuthorized = false;
+	m_accountDisabledEvent = NULL;
+	m_notificationsAvailableEvent = NULL;
 }
 
 /*
@@ -77,6 +121,7 @@ Return type: void
 */
 void AuthenticationManagementService::changePassword(const std::string& newPassword)
 {
+    AuthenticationManagementService::ensureAuthorization();
 	DataStoreLockGuard lock(m_dataStore);
 	auto& trackedUsersMap = m_dataStore.getUsers();
 	if (m_authenticatedUser == nullptr)
@@ -92,3 +137,17 @@ void AuthenticationManagementService::changePassword(const std::string& newPassw
 	trackedUsersMap.getValueAt(index).state = RecordState::MODIFIED;
 	m_dataStore.saveUsers();
 }
+
+/*
+Function: registerEvents
+Description: Registers menu event handles used to notify the active
+			 menu of account disable and notification events.
+Parameter: HANDLE accountDisabledEvent - account disabled event handle
+		   HANDLE notificationAvailableEvent - notification event handle
+Return type: void
+*/
+void AuthenticationManagementService::registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent)
+{
+	m_accountDisabledEvent = accountDisabledEvent;
+	m_notificationsAvailableEvent = notificationAvailableEvent;
+}

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

@@ -9,6 +9,8 @@ Date:19-May-2026
 
 #pragma once
 #include <string>
+#include <windows.h>
+#include "EventManager.h"
 #include "DataStore.h"
 
 class User;
@@ -17,11 +19,17 @@ class AuthenticationManagementService
 {
 private:
     static User* m_authenticatedUser;
+    static bool m_isAuthorized;
+    static EventManager m_eventManager;
+    static HANDLE m_accountDisabledEvent;
+    static HANDLE m_notificationsAvailableEvent;
     DataStore& m_dataStore;
 public:
     AuthenticationManagementService() : m_dataStore(DataStore::getInstance()) {}
+    static void ensureAuthorization();
     bool login(const std::string& username, const std::string& password);
     void logout();
     void changePassword(const std::string& newPassword);
     User* getAuthenticatedUser();
+    void registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent);
 };

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

@@ -14,11 +14,13 @@ Date: 22-May-2026
 #include "Factory.h"
 #include "InventoryItem.h"
 #include "InventoryManagementService.h"
+#include "AuthenticationManagementService.h"
 #include "Timestamp.h"
 #include "User.h"
 #include "Utility.h"
 #include "Vector.h"
 #include "DataStoreLockGuard.h"
+#include "EventManager.h"
 
 util::Map<std::string, User*> InventoryManagementService::m_observers{};
 
@@ -101,6 +103,7 @@ Return type: void
 */
 void InventoryManagementService::addInventoryItem(const std::string& partName, int quantity, double price)
 {
+    AuthenticationManagementService::ensureAuthorization();
 	DataStoreLockGuard lock(m_dataStore);
 	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
     InventoryItem* newItem = Factory::getObject<InventoryItem>(partName, quantity, price);
@@ -117,6 +120,7 @@ Return type: void
 */
 void InventoryManagementService::addInventoryItemStock(const std::string& selectedItemId, int quantity)
 {
+    AuthenticationManagementService::ensureAuthorization();
 	DataStoreLockGuard lock(m_dataStore);
 	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
 	int index = trackedInventoryItemMap.find(selectedItemId);
@@ -143,6 +147,7 @@ Return type: util::Map<std::string, InventoryItem*>
 */
 util::Map<std::string, InventoryItem*> InventoryManagementService::getInventoryItems()
 {
+    AuthenticationManagementService::ensureAuthorization();
 	DataStoreLockGuard lock(m_dataStore);
 	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
 	auto inventoryMap = util::getObjects(trackedInventoryItemMap);
@@ -157,6 +162,7 @@ Return type: void
 */
 void InventoryManagementService::removeInventoryItem(const std::string& inventoryItemID)
 {
+    AuthenticationManagementService::ensureAuthorization();
 	DataStoreLockGuard lock(m_dataStore);
 	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
 	int index = trackedInventoryItemMap.find(inventoryItemID);
@@ -182,6 +188,7 @@ Return type: InventoryItem*
 */
 InventoryItem* InventoryManagementService::getInventoryItem(const std::string& inventoryItemID)
 {
+    AuthenticationManagementService::ensureAuthorization();
 	DataStoreLockGuard lock(m_dataStore);
 	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
     int index = trackedInventoryItemMap.find(inventoryItemID);
@@ -269,6 +276,7 @@ void InventoryManagementService::sendNotification(User* user, const std::string&
 	{
 		return;
 	}
+	auto& trackedNotificationsMap = m_dataStore.getNotifications();
 	Notification* notification = Factory::getObject<Notification>(
 		user->getId(),
 		title,
@@ -278,8 +286,8 @@ void InventoryManagementService::sendNotification(User* user, const std::string&
 	{
 		throw std::runtime_error("Failed to create notification");
 	}
-	auto& trackedNotificationsMap = m_dataStore.getNotifications();
 	trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
 	m_dataStore.saveNotifications();
+	EventManager::sendNotificationAvailableEvent(user->getId());
 }
 

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

@@ -15,12 +15,15 @@ Date: 20-May-2026
 #include "Invoice.h"
 #include "JobCard.h"
 #include "PaymentManagementService.h"
+#include "AuthenticationManagementService.h"
+#include "DataStoreLockGuard.h"
 #include "Service.h"
 #include "ServiceBooking.h"
 #include "Timestamp.h"
 #include "User.h"
 #include "Utility.h"
 #include "DataStoreLockGuard.h"
+#include "EventManager.h"
 
 util::Map<std::string, User*> PaymentManagementService::m_observers{};
 
@@ -96,6 +99,7 @@ void PaymentManagementService::sendNotification(User* user, const std::string& t
 	{
 		return;
 	}
+	auto& trackedNotificationsMap = m_dataStore.getNotifications();
 	Notification* notification = Factory::getObject<Notification>(
 		user->getId(),
 		title,
@@ -105,9 +109,9 @@ void PaymentManagementService::sendNotification(User* user, const std::string& t
 	{
 		throw std::runtime_error("Failed to create notification");
 	}
-	auto& trackedNotificationsMap = m_dataStore.getNotifications();
 	trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
 	m_dataStore.saveNotifications();
+	EventManager::sendNotificationAvailableEvent(user->getId());
 }
 
 /*
@@ -121,11 +125,12 @@ Returns:
 */
 void PaymentManagementService::sendPaymentReminders()
 {
-	auto& invoicesMap = m_dataStore.getInvoices();
-	int invoicesMapSize = invoicesMap.getSize();
+	DataStoreLockGuard lock(m_dataStore);
+	auto& trackedInvoicesMap = m_dataStore.getInvoices();
+	int invoicesMapSize = trackedInvoicesMap.getSize();
 	for (int index = 0; index < invoicesMapSize; index++)
 	{
-		const Invoice* invoice = invoicesMap.getValueAt(index);
+		const Invoice* invoice = trackedInvoicesMap.getValueAt(index).data;
 		if (invoice && invoice->getStatus() == util::PaymentStatus::PENDING)
 		{
 			util::Timestamp invoiceCreationTimestamp = invoice->getInvoiceDate();
@@ -181,6 +186,7 @@ Throws:
 */
 void PaymentManagementService::generateInvoice(ServiceBooking* booking)
 {
+	DataStoreLockGuard lock(m_dataStore);
 	if (!booking)
 	{
 		throw std::runtime_error("Invoice generation failed: booking is null.");
@@ -190,10 +196,10 @@ void PaymentManagementService::generateInvoice(ServiceBooking* booking)
 	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++)
+	auto& currentTrackedJobCards = m_dataStore.getJobCards();
+	for (int iterator = 0; iterator < currentTrackedJobCards.getSize(); iterator++)
 	{
-		JobCard* currentJobCard = currentJobCards.getValueAt(iterator);
+		JobCard* currentJobCard = currentTrackedJobCards.getValueAt(iterator).data;
 		util::ServiceJobStatus currentJobCardStatus = currentJobCard->getStatus();
 		if (currentJobCard->getBookingId() == bookingID && currentJobCardStatus != util::ServiceJobStatus::CANCELLED && currentJobCardStatus != util::ServiceJobStatus::COMPLETED)
 		{
@@ -213,8 +219,9 @@ void PaymentManagementService::generateInvoice(ServiceBooking* booking)
 	totalServiceCost = totalLaborCost + totalPartsCost;
 	totalServiceCost -= (totalServiceCost * (discountPercentage / 100));
 	Invoice* invoice = Factory::getObject<Invoice>(bookingID, booking, util::Timestamp(), totalLaborCost, completeInventoryItemMapOfBooking, totalPartsCost, discountPercentage, totalServiceCost, util::Timestamp(), util::PaymentMode::NOTSET, util::PaymentStatus::PENDING);
-	util::Map<std::string, Invoice*>& currentInvoices = m_dataStore.getInvoices();
-	currentInvoices.insert(invoice->getId(), invoice);
+	auto& currentTrackedInvoices = m_dataStore.getInvoices();
+	currentTrackedInvoices.insert(invoice->getId(), util::createNewRecord(invoice));
+	m_dataStore.saveInvoices();
 }
 
 /*
@@ -227,11 +234,13 @@ Returns:
 */
 util::Map<std::string, Invoice*> PaymentManagementService::getInvoices(const std::string& customerID)
 {
-	util::Map<std::string, Invoice*>& currentInvoices = m_dataStore.getInvoices();
+    AuthenticationManagementService::ensureAuthorization();
+	DataStoreLockGuard lock(m_dataStore);
+	auto& currentTrackedInvoices = m_dataStore.getInvoices();
 	util::Map<std::string, Invoice*> currentUserInvoices;
-	for (int iterator = 0; iterator < currentInvoices.getSize(); iterator++)
+	for (int iterator = 0; iterator < currentTrackedInvoices.getSize(); iterator++)
 	{
-		Invoice* currentInvoice = currentInvoices.getValueAt(iterator);
+		Invoice* currentInvoice = currentTrackedInvoices.getValueAt(iterator).data;
 		if (currentInvoice->getBooking()->getCustomerId() == customerID)
 		{
 			currentUserInvoices.insert(currentInvoice->getId(), currentInvoice);
@@ -254,11 +263,14 @@ Throws:
 */
 void PaymentManagementService::completePayment(const std::string& invoiceID, util::PaymentMode paymentMode)
 {
-	auto& currentInvoices = m_dataStore.getInvoices();
-	int invoiceIndex = currentInvoices.find(invoiceID);
+    AuthenticationManagementService::ensureAuthorization();
+	DataStoreLockGuard lock(m_dataStore);
+	auto& currentTrackedInvoices = m_dataStore.getInvoices();
+	int invoiceIndex = currentTrackedInvoices.find(invoiceID);
 	if (invoiceIndex != -1)
 	{
-		Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
+		auto& trackedInvoice = currentTrackedInvoices.getValueAt(invoiceIndex);
+		Invoice* invoice = trackedInvoice.data;
 		if (invoice && invoice->getStatus() != util::PaymentStatus::PAID)
 		{
 			User* currentUser = invoice->getBooking()->getCustomer();
@@ -269,25 +281,31 @@ void PaymentManagementService::completePayment(const std::string& invoiceID, uti
 			title = "Payment successful";
 			message = "Payment successful for Invoice ID " + invoiceID;
 			sendNotification(currentUser, title, message);
+			trackedInvoice.state = RecordState::MODIFIED;
 		}
 	}
 	else
 	{
 		throw std::runtime_error("Payment failed: invalid invoice ID.");
 	}
+	m_dataStore.saveInvoices();
 }
 
 /*
-Function: getAllInvoice
+Function: getAllInvoices
 Description: Provides access to all invoices stored in the data store.
 Parameters:
 	- none
 Returns:
-	- util::Map<std::string, Invoice*>&: Map of invoice IDs to invoice objects
+	- util::Map<std::string, Invoice*>: Map of invoice IDs to invoice objects
 */
-util::Map<std::string, Invoice*>& PaymentManagementService::getAllInvoices()
+util::Map<std::string, Invoice*> PaymentManagementService::getAllInvoices()
 {
-	return m_dataStore.getInvoices();
+    AuthenticationManagementService::ensureAuthorization();
+	DataStoreLockGuard lock(m_dataStore);
+	util::Map<std::string, Invoice*> invoices;
+	invoices = util::getObjects(m_dataStore.getInvoices());
+	return invoices;
 }
 
 /*
@@ -303,20 +321,25 @@ Throws:
 */
 void PaymentManagementService::confirmPayment(const std::string& invoiceID)
 {
-	auto& currentInvoices = m_dataStore.getInvoices();
-	int invoiceIndex = currentInvoices.find(invoiceID);
+    AuthenticationManagementService::ensureAuthorization();
+	DataStoreLockGuard lock(m_dataStore);
+	auto& currentTrackedInvoices = m_dataStore.getInvoices();
+	int invoiceIndex = currentTrackedInvoices.find(invoiceID);
 	if (invoiceIndex == -1)
 	{
 		throw std::runtime_error("Payment confirmation failed: invalid invoice ID.");
 	}
-	Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
+	auto& trackedInvoice = currentTrackedInvoices.getValueAt(invoiceIndex);
+	Invoice* invoice = trackedInvoice.data;
 	if (!invoice || invoice->getStatus() != util::PaymentStatus::PAID)
 	{
 		throw std::runtime_error("Payment confirmation failed: invoice is not awaiting confirmation.");
 	}
 	User* currentUser = invoice->getBooking()->getCustomer();
 	invoice->setStatus(util::PaymentStatus::COMPLETED);
+	trackedInvoice.state = RecordState::MODIFIED;
 	std::string title = "Payment Confirmed";
 	std::string message = "Payment Confirmed for Invoice ID " + invoiceID;
 	sendNotification(currentUser, title, message);
+	m_dataStore.saveInvoices();
 }

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

@@ -27,7 +27,7 @@ public:
     void generateInvoice(ServiceBooking* booking);
     util::Map<std::string, Invoice*> getInvoices(const std::string& customerID);
     void completePayment(const std::string& invoiceID, util::PaymentMode paymentMode);
-    util::Map<std::string, Invoice*>& getAllInvoices();
+    util::Map<std::string, Invoice*> getAllInvoices();
     void confirmPayment(const std::string& invoiceID);
     void sendPaymentReminders();
     void sendNotification(User* user, const std::string& title, const std::string& message) override;

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

@@ -27,6 +27,32 @@ Date:19-May-2026
 #include "DataStoreLockGuard.h"
 #include "Utility.h"
 #include "DataStoreLockGuard.h"
+#include "EventManager.h"
+
+/*
+Function: notifyAllAdmins
+Description: Sends a notification to all users with the ADMIN role.
+             Iterates through the provided user collection and delivers
+             the specified notification to each administrator using the
+             ServiceManagementService notification mechanism.
+Parameter: const std::string& title - notification title
+Parameter: const std::string& message - notification message
+Parameter: const util::Map<std::string, TrackedRecord<User>>& users - collection of tracked users
+Parameter: ServiceManagementService* serviceManagementService - service used to dispatch notifications
+Return type: void
+*/
+static void notifyAllAdmins(const std::string& title, const std::string& message, const util::Map<std::string, TrackedRecord<User>>& users, ServiceManagementService* serviceManagementService)
+{
+    int numberOfUsers = users.getSize();
+    for (int index = 0; index < numberOfUsers; index++)
+    {
+        User* user = users.getValueAt(index).data;
+        if (user->getUserType() == util::UserType::ADMIN)
+        {
+            serviceManagementService->sendNotification(user, title, message);
+        }
+    }
+}
 
 /*
 Function: purchaseService
@@ -41,6 +67,7 @@ Return type: void
 */
 void ServiceManagementService::purchaseService(const util::Vector<std::string>& serviceIDs, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
 {
+    AuthenticationManagementService::ensureAuthorization();
 	AuthenticationManagementService m_authenticationManagementService;
 	auto authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
 	if (authenticatedUser == nullptr)
@@ -71,6 +98,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);
+    notifyAllAdmins("New Service Order Available", "A new service order has been placed with Service Booking ID " + serviceBooking->getId(), m_dataStore.getUsers(), this);
 }
 
 /*
@@ -86,6 +114,7 @@ Return type: void
 */
 void ServiceManagementService::purchaseComboPackage(const std::string& comboPackageID, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
 {
+    AuthenticationManagementService::ensureAuthorization();
 	AuthenticationManagementService m_authenticationManagementService;
 	auto authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
 	if (authenticatedUser == nullptr)
@@ -111,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);
+    notifyAllAdmins("New Combo Package Order Available", "A new combo package order has been placed with Service Booking ID " + serviceBooking->getId(), m_dataStore.getUsers(), this);
 }
 
 util::Map<std::string, User*> ServiceManagementService::m_observers{};
@@ -187,6 +217,7 @@ void ServiceManagementService::sendNotification(User* user, const std::string& t
     {
         return;
     }
+    auto& trackedNotificationsMap = m_dataStore.getNotifications();
     Notification* notification = Factory::getObject<Notification>(
         user->getId(),
         title,
@@ -196,9 +227,9 @@ void ServiceManagementService::sendNotification(User* user, const std::string& t
     {
         throw std::runtime_error("Failed to create notification");
     }
-    auto& trackedNotificationsMap = m_dataStore.getNotifications();
     trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
     m_dataStore.saveNotifications();
+    EventManager::sendNotificationAvailableEvent(user->getId());
 }
 
 /*
@@ -431,6 +462,7 @@ Return type: void
 */
 void ServiceManagementService::createComboPackage(const std::string& packageName, const util::Vector<std::string>& serviceIDsInNewCombo, double discountPercentage)
 {
+    AuthenticationManagementService::ensureAuthorization();
     DataStoreLockGuard lock(m_dataStore);
     if (packageName.empty())
     {
@@ -500,6 +532,7 @@ Return type: util::Map<std::string, ComboPackage*>
 */
 util::Map<std::string, ComboPackage*> ServiceManagementService::getComboPackages()
 {
+    AuthenticationManagementService::ensureAuthorization();
     DataStoreLockGuard lock(m_dataStore);
     util::Map<std::string, ComboPackage*> comboPackages;
     comboPackages = util::getObjects(m_dataStore.getComboPackages());
@@ -514,6 +547,7 @@ Return type: void
 */
 void ServiceManagementService::removeComboPackage(const std::string& comboPackageID)
 {
+    AuthenticationManagementService::ensureAuthorization();
     DataStoreLockGuard lock(m_dataStore);
     bool removed = false;
     auto& trackedComboPackages = m_dataStore.getComboPackages();
@@ -546,6 +580,7 @@ Returns:
 */
 util::Map<std::string, ServiceBooking*> ServiceManagementService::getServiceBookings()
 {
+    AuthenticationManagementService::ensureAuthorization();
     DataStoreLockGuard lock(m_dataStore);
     util::Map<std::string, ServiceBooking*> serviceBookings;
     serviceBookings = util::getObjects(m_dataStore.getServiceBookings());
@@ -562,6 +597,7 @@ Returns:
 */
 ServiceBooking* ServiceManagementService::getServiceBooking(const std::string& serviceID)
 {
+    AuthenticationManagementService::ensureAuthorization();
 	auto currentServiceBookings = getServiceBookings();
 	for (int iterator = 0; iterator < currentServiceBookings.getSize(); iterator++)
 	{
@@ -588,6 +624,7 @@ Throws:
 */
 void ServiceManagementService::createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID)
 {
+    AuthenticationManagementService::ensureAuthorization();
     DataStoreLockGuard lock(m_dataStore);
 	UserManagementService m_userManagementService;
 	ServiceBooking* currentBooking = getServiceBooking(bookingID);
@@ -665,6 +702,7 @@ Throws:
 */
 void ServiceManagementService::createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost)
 {
+    AuthenticationManagementService::ensureAuthorization();
     DataStoreLockGuard lock(m_dataStore);
 	util::Map<std::string, InventoryItem*> currentServiceInventoryItems;
 	auto& trackedInventoryItems = m_dataStore.getInventoryItems();
@@ -711,6 +749,7 @@ Returns:
 */
 util::Map<std::string, Service*> ServiceManagementService::getServices()
 {
+    AuthenticationManagementService::ensureAuthorization();
     DataStoreLockGuard lock(m_dataStore);
     util::Map<std::string, Service*> services;
     services = util::getObjects(m_dataStore.getServices());
@@ -729,6 +768,7 @@ Throws:
 */
 void ServiceManagementService::removeService(const std::string& serviceID)
 {
+    AuthenticationManagementService::ensureAuthorization();
     DataStoreLockGuard lock(m_dataStore);
 	auto& currentTrackedServices = m_dataStore.getServices();
     auto& currentTrackedComboPackages =  m_dataStore.getComboPackages();
@@ -776,6 +816,7 @@ Returns:
 */
 util::Map<std::string, ServiceBooking*> ServiceManagementService::getServiceBookings(const std::string& customerID)
 {
+    AuthenticationManagementService::ensureAuthorization();
 	util::Map<std::string, ServiceBooking*> currentServiceBookings = getServiceBookings();
 	util::Map<std::string, ServiceBooking*> currentUserServiceBookings;
 	if (currentServiceBookings.getSize() != 0)
@@ -802,6 +843,7 @@ Returns:
 */
 util::Map<std::string, JobCard*> ServiceManagementService::getJobCards(const std::string& technicianID)
 {
+    AuthenticationManagementService::ensureAuthorization();
     DataStoreLockGuard lock(m_dataStore);
 	auto& trackedJobCards = m_dataStore.getJobCards();
 	util::Map<std::string, JobCard*> technicianJobCards;
@@ -856,6 +898,7 @@ Returns:
 */
 void ServiceManagementService::updateJobStatus(const std::string& jobID)
 {
+    AuthenticationManagementService::ensureAuthorization();
     DataStoreLockGuard lock(m_dataStore);
 	AuthenticationManagementService authenticationManagementService;
 	PaymentManagementService paymentManagementService;

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

@@ -15,6 +15,7 @@ Date:19-May-2026
 #include "Notification.h"
 #include "PaymentManagementService.h"
 #include "ServiceManagementService.h"
+#include "AuthenticationManagementService.h"
 #include "User.h"
 #include "UserManagementService.h"
 #include "Vector.h"
@@ -22,6 +23,7 @@ Date:19-May-2026
 #include "Utility.h"
 #include "TrackedRecord.h"
 #include "DataStoreLockGuard.h"
+#include "EventManager.h"
 
 /*
 Function: ensureAdminExists
@@ -113,6 +115,7 @@ Return type: void
 */
 void UserManagementService::updateUserDetails(const std::string& userID, const std::string& email, const std::string& phone)
 {
+    AuthenticationManagementService::ensureAuthorization();
 	DataStoreLockGuard lock(m_dataStore);
 	auto& trackedUsersMap = m_dataStore.getUsers();
 	auto usersMap = util::getObjects(trackedUsersMap);
@@ -160,6 +163,7 @@ Throws:
 */
 util::Vector<Notification*> UserManagementService::getUserNotifications(const std::string& userID)
 {
+    AuthenticationManagementService::ensureAuthorization();
 	DataStoreLockGuard lock(m_dataStore);
 	auto& trackedUsersMap = m_dataStore.getUsers(); 
 	if (trackedUsersMap.find(userID) == -1)
@@ -203,6 +207,7 @@ Throws:
 */
 void UserManagementService::deleteNotification(const std::string& notificationID, const std::string& userID)
 {
+    AuthenticationManagementService::ensureAuthorization();
 	DataStoreLockGuard lock(m_dataStore);
 	auto& trackedUsersMap = m_dataStore.getUsers();
 	auto& trackedNotificationsMap = m_dataStore.getNotifications();
@@ -264,33 +269,42 @@ Return type: void
 */
 void UserManagementService::removeUser(const std::string& userID)
 {
+    AuthenticationManagementService::ensureAuthorization();
 	InventoryManagementService inventoryManagementService;
 	PaymentManagementService paymentManagementService;
 	ServiceManagementService serviceManagementService;
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	int index = trackedUsersMap.find(userID);
-	if (index != -1)
+	std::string removedUserID;
 	{
-		User* user = trackedUsersMap.getValueAt(index).data;
-		if (user != nullptr)
+		DataStoreLockGuard lock(m_dataStore);
+		auto& trackedUsersMap = m_dataStore.getUsers();
+		int index = trackedUsersMap.find(userID);
+		if (index != -1)
 		{
-			if (user->getUserType() == util::UserType::CUSTOMER)
+			User* user = trackedUsersMap.getValueAt(index).data;
+			if (user != nullptr)
 			{
-				serviceManagementService.cancelCustomerServiceBookings(userID);
+				if (user->getUserType() == util::UserType::CUSTOMER)
+				{
+					serviceManagementService.cancelCustomerServiceBookings(userID);
+				}
+				if (user->getUserType() == util::UserType::TECHNICIAN)
+				{
+					serviceManagementService.cancelTechnicianJobs(userID);
+				}
+				inventoryManagementService.detach(user);
+				paymentManagementService.detach(user);
+				serviceManagementService.detach(user);
+				user->setState(util::State::INACTIVE);
+				trackedUsersMap.getValueAt(index).state = RecordState::MODIFIED;
+				removedUserID = user->getId();
+				m_dataStore.saveUsers();
 			}
-			if (user->getUserType() == util::UserType::TECHNICIAN)
-			{
-				serviceManagementService.cancelTechnicianJobs(userID);
-			}
-			inventoryManagementService.detach(user);
-			paymentManagementService.detach(user);
-			serviceManagementService.detach(user);
-			user->setState(util::State::INACTIVE);
-			trackedUsersMap.getValueAt(index).state = RecordState::MODIFIED;
-			m_dataStore.saveUsers();
 		}
 	}
+	if (!removedUserID.empty())
+	{
+		EventManager::sendUserDisabledEvent(removedUserID);
+	}
 }
 
 /*

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

@@ -30,10 +30,16 @@ Return type: void
 */
 void AdminMenu::showMenu()
 {
+	startEventListener();
     while (true)
     {
         try
         {
+			if (!m_isMenuActive)
+			{
+				logout();
+				break;
+			}
             int choice;
             util::clear();
             std::cout << "Admin Menu"
@@ -68,6 +74,7 @@ void AdminMenu::showMenu()
             util::pressEnter();
         }
     }
+	stopEventListener();
 }
 
 /*
@@ -78,6 +85,11 @@ Return type: bool - true if menu continues, false if logout
 */
 bool AdminMenu::handleOperation(int choice)
 {
+	if (!m_isMenuActive)
+	{
+		logout();
+		return false;
+	}
     switch (choice)
     {
     case 1:
@@ -141,6 +153,19 @@ bool AdminMenu::handleOperation(int choice)
     return true;
 }
 
+/*
+Function: handleNotificationEvent
+Description: Retrieves and displays the latest notification for the
+			 currently logged in admin.
+Parameter: None
+Return type: void
+*/
+void AdminMenu::handleNotificationEvent()
+{
+	auto notifications = m_controller.getNotifications();
+	displayNewNotification(notifications);
+}
+
 /*
 Function: logout
 Description: Logs out the currently authenticated admin user.

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

@@ -9,12 +9,13 @@ Date:19-May-2026
 
 #pragma once
 #include "Controller.h"
+#include "Menu.h"
 
-class AdminMenu
+class AdminMenu : public Menu
 {
 private:
-    Controller m_controller;
     bool handleOperation(int choice);
+    void handleNotificationEvent() override;
 public:
     void showMenu();
     void logout();

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

@@ -32,10 +32,17 @@ Return type: void
 */
 void CustomerMenu::showMenu()
 {
+
+    startEventListener();
     while (true)
     {
         try
         {
+            if (!m_isMenuActive)
+            {
+                logout();
+                break;
+            }
             int choice;
             util::clear();
             std::cout << "Customer Menu"
@@ -62,6 +69,7 @@ void CustomerMenu::showMenu()
             util::pressEnter();
         }
     }
+    stopEventListener();
 }
 
 /*
@@ -72,6 +80,11 @@ Return type: bool - true if menu continues, false if logout
 */
 bool CustomerMenu::handleOperation(int choice)
 {
+    if (!m_isMenuActive)
+    {
+        logout();
+        return false;
+    }
     switch (choice)
     {
     case 1:
@@ -111,6 +124,19 @@ bool CustomerMenu::handleOperation(int choice)
     return true;
 }
 
+/*
+Function: handleNotificationEvent
+Description: Retrieves and displays the latest notification for the
+             currently logged in admin.
+Parameter: None
+Return type: void
+*/
+void CustomerMenu::handleNotificationEvent()
+{
+    auto notifications = m_controller.getNotifications();
+    displayNewNotification(notifications);
+}
+
 /*
 Function: logout
 Description: Logs out the currently authenticated customer user.

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

@@ -9,13 +9,14 @@ Date:19-May-2026
 */
 
 #pragma once
+#include "Menu.h"
 #include "Controller.h"
 
-class CustomerMenu
+class CustomerMenu : public Menu
 {
 private:
-    Controller m_controller;
     bool handleOperation(int choice);
+    void handleNotificationEvent();
 public:
     void showMenu();
     void logout();

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

@@ -0,0 +1,144 @@
+/*
+File: Menu.cpp
+Description: Implementation file containing common menu event listener
+             functionality, account disable handling, and notification
+             event dispatching for all menu types.
+Author: Trenser
+Date:16-Jun-2026
+*/
+
+#include "Menu.h"
+
+/*
+Function: Menu
+Description: Constructs a Menu object and initializes event handles
+             and menu state.
+Parameter: None
+Return type: None
+*/
+Menu::Menu()
+    :
+    m_isMenuActive(false),
+    m_accountDisabledEvent(NULL),
+    m_notificationAvailableEvent(NULL),
+    m_shutdownEvent(NULL) {}
+
+/*
+Function: ~Menu
+Description: Destroys the Menu object and performs event listener
+             cleanup.
+Parameter: None
+Return type: None
+*/
+Menu::~Menu()
+{
+    stopEventListener();
+}
+
+/*
+Function: startEventListener
+Description: Creates menu event handles, registers them with the
+             authentication service, and starts the event listener
+             thread.
+Parameter: None
+Return type: void
+*/
+void Menu::startEventListener()
+{
+    if (m_isMenuActive.load())
+    {
+        return;
+    }
+    m_isMenuActive.store(true);
+    m_accountDisabledEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
+    m_notificationAvailableEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
+    m_shutdownEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
+    m_controller.registerEvents(m_accountDisabledEvent, m_notificationAvailableEvent);
+    m_eventListenerThread = std::thread(&Menu::eventListenerLoop, this);
+}
+
+/*
+Function: eventListenerLoop
+Description: Waits for account disabled, notification available,
+             and shutdown events and dispatches them to the
+             appropriate handlers.
+Parameter: None
+Return type: void
+*/
+void Menu::eventListenerLoop()
+{
+    HANDLE handles[3];
+    handles[0] = m_accountDisabledEvent;
+    handles[1] = m_notificationAvailableEvent;
+    handles[2] = m_shutdownEvent;
+    while (m_isMenuActive.load())
+    {
+        DWORD result = WaitForMultipleObjects(3, handles, FALSE, INFINITE);
+        switch (result)
+        {
+        case WAIT_OBJECT_0:
+            handleAccountDisabledEvent();
+            break;
+        case WAIT_OBJECT_0 + 1:
+            handleNotificationEvent();
+            break;
+        case WAIT_OBJECT_0 + 2:
+            return;
+        }
+    }
+}
+
+/*
+Function: stopEventListener
+Description: Stops the event listener thread and releases all
+             associated event handles.
+Parameter: None
+Return type: void
+*/
+void Menu::stopEventListener()
+{
+    m_isMenuActive.store(false);
+    if (m_shutdownEvent)
+    {
+        SetEvent(m_shutdownEvent);
+    }
+    if (m_eventListenerThread.joinable())
+    {
+        m_eventListenerThread.join();
+    }
+    if (m_accountDisabledEvent)
+    {
+        CloseHandle(m_accountDisabledEvent);
+    }
+    if (m_notificationAvailableEvent)
+    {
+        CloseHandle(m_notificationAvailableEvent);
+    }
+    if (m_shutdownEvent)
+    {
+        CloseHandle(m_shutdownEvent);
+    }
+    m_accountDisabledEvent = NULL;
+    m_notificationAvailableEvent = NULL;
+    m_shutdownEvent = NULL;
+}
+
+/*
+Function: handleAccountDisabledEvent
+Description: Handles an account disabled event by marking the menu
+             inactive and notifying the user.
+Parameter: None
+Return type: void
+*/
+void Menu::handleAccountDisabledEvent()
+{
+    m_isMenuActive.store(false);
+    MessageBoxA(
+        GetConsoleWindow(),
+        "Your account has been disabled.",
+        "Account Disabled",
+        MB_OK |
+        MB_ICONWARNING |
+        MB_SETFOREGROUND |
+        MB_TOPMOST);
+}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/Menu.h

@@ -0,0 +1,33 @@
+/*
+File: Menu.h
+Description: Base class providing common event listener functionality
+             for all menu implementations.
+Author: Trenser
+Date:16-Jun-2026
+*/
+
+#pragma once
+
+#include <windows.h>
+#include <atomic>
+#include <thread>
+#include "Controller.h"
+
+class Menu
+{
+protected:
+    Controller m_controller;
+    std::atomic<bool> m_isMenuActive;
+    HANDLE m_accountDisabledEvent;
+    HANDLE m_notificationAvailableEvent;
+    HANDLE m_shutdownEvent;
+    std::thread m_eventListenerThread;
+    void startEventListener();
+    void stopEventListener();
+    void eventListenerLoop();
+    void handleAccountDisabledEvent();
+    virtual void handleNotificationEvent() = 0;
+public:
+    Menu();
+    virtual ~Menu();
+};

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

@@ -1408,3 +1408,37 @@ inline std::string selectComboPackage(util::Map<std::string, const ComboPackage*
         return "";
     }
 }
+
+/*
+Function: displayNewNotification
+Description: Displays the most recent notification from the supplied
+             notification collection.
+Parameter: util::Vector<const Notification*> notifications -
+           collection of notifications
+Return type: void
+*/
+inline void displayNewNotification(util::Vector<const Notification*> notifications)
+{
+    const Notification* notification = nullptr;
+	size_t numberOfNotifications = notifications.getSize();
+	for (int index = 0; index < numberOfNotifications; index++)
+	{
+		if (!notification)
+		{
+			notification = notifications[index];
+		}
+		else
+		{
+			if (notification->getId() < notifications[index]->getId())
+			{
+				notification = notifications[index];
+			}
+		}
+	}
+    MessageBoxA(
+        GetConsoleWindow(),
+        notification->getMessage().c_str(),
+        notification->getTitle().c_str(),
+        MB_OK |
+        MB_ICONINFORMATION);
+}

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

@@ -27,10 +27,16 @@ Returns:
 */
 void TechnicianMenu::showMenu()
 {
+    startEventListener();
     while (true)
     {
         try
         {
+            if (!m_isMenuActive)
+            {
+                logout();
+                break;
+            }
             int choice;
             util::clear();
             std::cout << "Technician Menu"
@@ -52,6 +58,7 @@ void TechnicianMenu::showMenu()
             util::pressEnter();
         }
     }
+    stopEventListener();
 }
 
 /*
@@ -62,6 +69,11 @@ Return type: bool - true if menu continues, false if logout
 */
 bool TechnicianMenu::handleOperation(int choice)
 {
+    if (!m_isMenuActive)
+    {
+        logout();
+        return false;
+    }
     switch (choice)
     {
     case 1:
@@ -86,6 +98,19 @@ bool TechnicianMenu::handleOperation(int choice)
     return true;
 }
 
+/*
+Function: handleNotificationEvent
+Description: Retrieves and displays the latest notification for the
+             currently logged in admin.
+Parameter: None
+Return type: void
+*/
+void TechnicianMenu::handleNotificationEvent()
+{
+    auto notifications = m_controller.getNotifications();
+    displayNewNotification(notifications);
+}
+
 /*
 Function: displayJobs
 Description: Displays all Jobs assigned to a Technician

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

@@ -9,12 +9,13 @@ Date:19-May-2026
 
 #pragma once
 #include "Controller.h"
+#include "Menu.h"
 
-class TechnicianMenu
+class TechnicianMenu : public Menu
 {
 private:
-    Controller m_controller;
     bool handleOperation(int choice);
+    void handleNotificationEvent();
 public:
     void showMenu();
     void displayJobs();