Merged PR 1200: Fix Customer Allowed to Create Service Bookings While Having Unpaid Invoices

Changes: - 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. Related work items: #2116
Implement review fixes
2026-06-18 19:55:12 +05:30 · 2026-06-18 19:54:12 +05:30 · 2026-06-18 19:44:35 +05:30 · 2026-06-18 19:43:41 +05:30 · 2026-06-18 19:37:31 +05:30 · 2026-06-18 19:31:18 +05:30
54 changed files with 2071 additions and 1655 deletions
@@ -427,5 +427,5 @@ FodyWeavers.xsd
 *.msm
 *.msp

-# CSV Files
-*.csv
+# DAT Files
+*.dat
@@ -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" />
@@ -140,7 +141,6 @@
    <ClCompile Include="models\User.cpp" />
    <ClCompile Include="services\AuthenticationManagementService.cpp" />
    <ClCompile Include="services\InventoryManagementService.cpp" />
-    <ClCompile Include="services\NotificationManagementService.cpp" />
    <ClCompile Include="services\PaymentManagementService.cpp" />
    <ClCompile Include="services\ServiceManagementService.cpp" />
    <ClCompile Include="services\UserManagementService.cpp" />
@@ -149,20 +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\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="datastores\DataStoreLockGuard.h" />
    <ClInclude Include="factories\Factory.h" />
    <ClInclude Include="models\ComboPackage.h" />
    <ClInclude Include="models\InventoryItem.h" />
@@ -181,7 +184,6 @@
    <ClInclude Include="utilities\Config.h" />
    <ClInclude Include="utilities\Enums.h" />
    <ClInclude Include="utilities\FileHelper.h" />
-    <ClInclude Include="utilities\FileManager.h" />
    <ClInclude Include="utilities\InputHelper.h" />
    <ClInclude Include="utilities\Map.h" />
    <ClInclude Include="utilities\OutputHelper.h" />
@@ -192,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" />
@@ -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>
@@ -114,9 +120,6 @@
    <ClCompile Include="datastores\DataStore.cpp">
      <Filter>Source Files\DataStores</Filter>
    </ClCompile>
-    <ClCompile Include="services\NotificationManagementService.cpp">
-      <Filter>Source Files\Services</Filter>
-    </ClCompile>
    <ClCompile Include="core\patterns\Observer.cpp">
      <Filter>Source Files\Core\Patterns</Filter>
    </ClCompile>
@@ -147,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>
@@ -245,9 +254,6 @@
    <ClInclude Include="utilities\Config.h">
      <Filter>Header Files\Utilities</Filter>
    </ClInclude>
-    <ClInclude Include="utilities\FileManager.h">
-      <Filter>Header Files\Utilities</Filter>
-    </ClInclude>
    <ClInclude Include="utilities\StringHelper.h">
      <Filter>Header Files\Utilities</Filter>
    </ClInclude>
@@ -260,23 +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 Include="datastores\DataStoreLockGuard.h">
+      <Filter>Header Files\DataStores</Filter>
    </ClInclude>
-    <ClInclude Include="datastores\sharedmemory\MappingInfo.h">
-      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    <ClInclude Include="core\sharedmemory\FileHeader.h">
+      <Filter>Header Files\Core\SharedMemory</Filter>
    </ClInclude>
-    <ClInclude Include="datastores\sharedmemory\RecordState.h">
-      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    <ClInclude Include="core\sharedmemory\MappingInfo.h">
+      <Filter>Header Files\Core\SharedMemory</Filter>
    </ClInclude>
-    <ClInclude Include="datastores\sharedmemory\TrackedRecord.h">
-      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    <ClInclude Include="core\sharedmemory\RecordState.h">
+      <Filter>Header Files\Core\SharedMemory</Filter>
    </ClInclude>
-    <ClInclude Include="datastores\sharedmemory\SerializedRecords.h">
-      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    <ClInclude Include="core\sharedmemory\SerializedRecords.h">
+      <Filter>Header Files\Core\SharedMemory</Filter>
    </ClInclude>
-    <ClInclude Include="datastores\sharedmemory\SharedMemory.h">
-      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    <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>
@@ -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.
@@ -588,63 +600,50 @@ void Controller::configureNotifications(bool paymentNotifications, bool serviceN
 }

 /*
-Function: loadSystemData
-Description: Loads all system data from persistent storage into memory.
-             Invokes the respective management services to load users, inventory items, services,
-             combo packages, service bookings, job cards, invoices, and observers.
+Function: initialize
+Description: Initializes the system and run system checks to ensure critical configurations, such as verifying admin existence.
 Parameters:
    - None
 Returns:
-    - void
+    - bool
 */
-void Controller::loadSystemData()
+bool Controller::initialize()
 {
-    m_userManagementService.loadUsers();
-    m_inventoryManagementService.loadInventoryItems();
-    m_serviceManagementService.loadServices();
-    m_serviceManagementService.loadComboPackages();
-    m_serviceManagementService.loadServiceBookings();
-    m_serviceManagementService.loadJobCards();
-    m_paymentManagementService.loadInvoices();
-    m_serviceManagementService.loadObservers();
-    m_paymentManagementService.loadObservers();
-    m_inventoryManagementService.loadObservers();
-}
+    auto& dataStore = DataStore::getInstance();

-/*
-Function: saveSystemData
-Description: Saves all system data from memory back to persistent storage.
-             Invokes the respective management services to save users, inventory items, services,
-             combo packages, service bookings, job cards, invoices, and observers.
-Parameters:
-    - None
-Returns:
-    - void
-*/
-void Controller::saveSystemData()
-{
-    m_userManagementService.saveUsers();
-    m_inventoryManagementService.saveInventoryItems();
-    m_serviceManagementService.saveServices();
-    m_serviceManagementService.saveComboPackages();
-    m_serviceManagementService.saveServiceBookings();
-    m_serviceManagementService.saveJobCards();
-    m_paymentManagementService.saveInvoices();
-    m_serviceManagementService.saveObservers();
-    m_paymentManagementService.saveObservers();
-    m_inventoryManagementService.saveObservers();
-}
-
-/*
-Function: runSystemChecks
-Description: Runs system checks to ensure critical configurations, such as verifying admin existence.
-Parameter: None
-Return type: void
-*/
-void Controller::runSystemChecks()
-{
+    if (!dataStore.initialize())
+    {
+        return false;
+    }
    m_userManagementService.ensureAdminExists();
    m_inventoryManagementService.sendLowStockAlerts();
    m_paymentManagementService.sendPaymentReminders();
+    return true;
 }

+/*
+Function: shutdown
+Description: Shutdown the system, and do necessary cleanups
+Parameters:
+    - None
+Returns:
+    - void
+*/
+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);
+}
@@ -8,6 +8,7 @@ Date:19-May-2026
 */

 #pragma once
+#include <windows.h>
 #include <string>
 #include "AuthenticationManagementService.h"
 #include "Enums.h"
@@ -57,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);
@@ -70,7 +72,7 @@ public:
    util::Vector<const Notification*> getNotifications();
    void deleteNotification(const std::string& notificationID);
    void configureNotifications(bool paymentNotifications, bool serviceNotifications);
-    void loadSystemData();
-    void saveSystemData();
-    void runSystemChecks();
+    bool initialize();
+    void shutdown();
+    void registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent);
 };
@@ -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);
+}
@@ -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);
+};
@@ -7,11 +7,8 @@ Date: 19-May-2026

 #pragma once

-class Notification;
-
 class Observer
 {
 public:
    virtual ~Observer() = default;
-    virtual void addNotification(Notification* notification) = 0;
 };
@@ -10,6 +10,7 @@ Created: 11-June-2026
 */

 #include "SharedMemory.h"
+#include "Windows.h"
 #include "Config.h"

 /*
@@ -319,7 +320,7 @@ bool SharedMemory::ensureCapacityForInsert(MappingInfo& mapping)
    {
        return true;
    }
-    return resizeMapping(mapping, capacity * 2);
+    return resizeMapping(mapping, capacity * config::file::GROWTH_FACTOR);
 }

 /*
@@ -12,6 +12,9 @@ Date: 19-May-2026
 #include "Config.h"
 #include "SerializedRecords.h"
 #include "FileHelper.h"
+#include "ServiceBooking.h"
+#include "JobCard.h"
+#include "Invoice.h"

 /*
 Function: DataStore
@@ -144,11 +147,6 @@ bool DataStore::initialize()
            success = false;
            break;
        }
-        if (!SharedMemory::createOrOpenMapping(m_payments))
-        {
-            success = false;
-            break;
-        }
        if (!SharedMemory::createOrOpenMapping(m_serviceManagementObservers))
        {
            success = false;
@@ -193,7 +191,6 @@ void DataStore::shutdown()
    SharedMemory::closeMapping(m_serviceBookings);
    SharedMemory::closeMapping(m_jobCards);
    SharedMemory::closeMapping(m_invoices);
-    SharedMemory::closeMapping(m_payments);
    SharedMemory::closeMapping(m_serviceManagementObservers);
    SharedMemory::closeMapping(m_paymentManagementObservers);
    SharedMemory::closeMapping(m_inventoryManagementObservers);
@@ -228,6 +225,8 @@ Returns:
 */
 util::Map<std::string, TrackedRecord<User>>& DataStore::getUsers()
 {
+    auto users = loadRecords<User, SerializedUser>(m_users);
+    refreshCache(m_userCache, users);
    return m_userCache;
 }

@@ -241,6 +240,8 @@ Returns:
 */
 util::Map<std::string, TrackedRecord<Notification>>& DataStore::getNotifications()
 {
+    auto notifications = loadRecords<Notification, SerializedNotification>(m_notifications);
+    refreshCache(m_notificationCache, notifications);
    return m_notificationCache;
 }

@@ -254,6 +255,28 @@ Returns:
 */
 util::Map<std::string, TrackedRecord<Service>>& DataStore::getServices()
 {
+    util::Map<std::string, TrackedRecord<Service>> services = loadRecords<Service, SerializedService>(m_services);
+    refreshCache(m_serviceCache, services);
+    util::Map<std::string, TrackedRecord<InventoryItem>>& inventoryItems = getInventoryItems();
+    size_t numberOfServices = m_serviceCache.getSize();
+    for (int iteratorOne =0; iteratorOne < numberOfServices; iteratorOne++)
+    {
+        Service* currentService = m_serviceCache.getValueAt(iteratorOne).data;
+        util::Map<std::string, InventoryItem*> inventoryItemMap;
+        util::Vector<std::string> currentServiceInventoryItem = currentService->getRequiredInventoryItemIDs();
+        for (int iteratorTwo = 0; iteratorTwo < currentServiceInventoryItem.getSize(); iteratorTwo++)
+        {
+            const std::string& currentInventoryItemId = currentServiceInventoryItem[iteratorTwo];
+            int currentInventoryItemIndex = inventoryItems.find(currentInventoryItemId);
+            if (currentInventoryItemIndex == -1)
+            {
+                throw std::runtime_error("Invalid inventory item ID");
+            }
+            InventoryItem* currentItem = inventoryItems.getValueAt(currentInventoryItemIndex).data;
+            inventoryItemMap[currentInventoryItemId] = currentItem;
+        }
+        currentService->setRequiredInventoryItems(inventoryItemMap);
+    }
    return m_serviceCache;
 }

@@ -267,6 +290,28 @@ Returns:
 */
 util::Map<std::string, TrackedRecord<ComboPackage>>& DataStore::getComboPackages()
 {
+    util::Map<std::string, TrackedRecord<ComboPackage>> comboPackages = loadRecords<ComboPackage, SerializedComboPackage>(m_comboPackages);
+    refreshCache(m_comboPackageCache, comboPackages);
+    util::Map<std::string, TrackedRecord<Service>>& services = getServices();
+    size_t numberOfComboPackages = m_comboPackageCache.getSize();
+    for (int iteratorOne = 0; iteratorOne < numberOfComboPackages; iteratorOne++)
+    {
+        ComboPackage* currentComboPackage =  m_comboPackageCache.getValueAt(iteratorOne).data;
+        util::Vector<std::string> currentServiceIds = currentComboPackage->getServiceIDs();
+        util::Map<std::string, Service*> currentComboPackageServices;
+        for (int iteratorTwo = 0; iteratorTwo < currentServiceIds.getSize(); iteratorTwo++)
+        {
+            const std::string& currentServiceId = currentServiceIds[iteratorTwo];
+            int serviceIndex = services.find(currentServiceId);
+            if (serviceIndex == -1)
+            {
+                throw std::runtime_error("Invalid service ID");
+            }
+            Service* currentService = services.getValueAt(serviceIndex).data;
+            currentComboPackageServices[currentServiceId] = currentService;
+        }
+        currentComboPackage->setServices(currentComboPackageServices);
+    }
    return m_comboPackageCache;
 }

@@ -280,6 +325,8 @@ Returns:
 */
 util::Map<std::string, TrackedRecord<InventoryItem>>& DataStore::getInventoryItems()
 {
+    auto inventoryItems = loadRecords<InventoryItem, SerializedInventoryItem>(m_inventoryItems);
+    refreshCache(m_inventoryItemCache, inventoryItems);
    return m_inventoryItemCache;
 }

@@ -293,6 +340,49 @@ Returns:
 */
 util::Map<std::string, TrackedRecord<ServiceBooking>>& DataStore::getServiceBookings()
 {
+    util::Map<std::string, TrackedRecord<ServiceBooking>> serviceBookings = loadRecords<ServiceBooking, SerializedServiceBooking>(m_serviceBookings);
+    refreshCache(m_serviceBookingCache, serviceBookings);
+    auto& users = getUsers();
+    auto& services = getServices();
+    size_t numberOfServiceBookings = m_serviceBookingCache.getSize();
+    for (int iteratorOne = 0; iteratorOne < numberOfServiceBookings; iteratorOne++)
+    {
+        ServiceBooking* serviceBooking = m_serviceBookingCache.getValueAt(iteratorOne).data;
+        auto& serviceIds = serviceBooking->getServiceIDs();
+        util::Map<std::string, Service*> servicesInBooking;
+        for (int iteratorTwo = 0; iteratorTwo < serviceIds.getSize(); iteratorTwo++)
+        {
+            const std::string& currentServiceId = serviceIds[iteratorTwo];
+            int serviceIndex = services.find(currentServiceId);
+            if (serviceIndex == -1)
+            {
+                throw std::runtime_error("Invalid service index.");
+            }
+            auto& currentService = services.getValueAt(serviceIndex);
+            servicesInBooking[currentServiceId] = currentService.data;
+        }
+        serviceBooking->setServices(servicesInBooking);
+        if (!serviceBooking->getCustomerId().empty())
+        {
+            int userIndex = users.find(serviceBooking->getCustomerId());
+            if (userIndex == -1)
+            {
+                throw std::runtime_error("Invalid user index.");
+            }
+            auto& customer = users.getValueAt(userIndex);
+            serviceBooking->setCustomer(customer.data);
+        }
+        if (!serviceBooking->getAssignedTechnicianId().empty())
+        {
+            int technicianIndex = users.find(serviceBooking->getAssignedTechnicianId());
+            if (technicianIndex == -1)
+            {
+                throw std::runtime_error("Invalid technician index.");
+            }
+            auto& technician = users.getValueAt(technicianIndex);
+            serviceBooking->setAssignedTechnician(technician.data);
+        }
+    }
    return m_serviceBookingCache;
 }

@@ -306,9 +396,51 @@ Returns:
 */
 util::Map<std::string, TrackedRecord<JobCard>>& DataStore::getJobCards()
 {
+    util::Map<std::string, TrackedRecord<JobCard>> jobCards = loadRecords<JobCard, SerializedJobCard>(m_jobCards);
+    refreshCache(m_jobCardCache, jobCards);
+    auto& serviceBookings = getServiceBookings();
+    auto& services = getServices();
+    auto& users = getUsers();
+    int numberOfJobCards = m_jobCardCache.getSize();
+    for (int iterator = 0; iterator < numberOfJobCards; iterator++)
+    {
+        JobCard* jobCard = m_jobCardCache.getValueAt(iterator).data;
+        if (!jobCard)
+        {
+            continue;
+        }
+        const std::string& bookingId = jobCard->getBookingId();
+        int bookingIndex = serviceBookings.find(bookingId);
+        if (bookingIndex == -1)
+        {
+            throw std::runtime_error("Invalid booking ID: " + bookingId);
+        }
+        auto& trackedBooking = serviceBookings.getValueAt(bookingIndex);
+        jobCard->setBooking(trackedBooking.data);
+        const std::string& serviceId = jobCard->getServiceId();
+        int serviceIndex = services.find(serviceId);
+        if (serviceIndex == -1)
+        {
+            throw std::runtime_error("Invalid service ID: " + serviceId);
+        }
+        auto& trackedService = services.getValueAt(serviceIndex);
+        jobCard->setService(trackedService.data);
+        const std::string& technicianId = jobCard->getTechnicianId();
+        if (!technicianId.empty())
+        {
+            int technicianIndex = users.find(technicianId);
+            if (technicianIndex == -1)
+            {
+                throw std::runtime_error("Invalid technician ID: " + technicianId);
+            }
+            auto& trackedTechnician = users.getValueAt(technicianIndex);
+            jobCard->setTechnician(trackedTechnician.data);
+        }
+    }
    return m_jobCardCache;
 }

+
 /*
 Function: getInvoices
 Description: Retrieves all invoice records from the datastore.
@@ -319,9 +451,79 @@ 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;
 }

+/*
+Function: getObservers
+Description: Retrieves observer records from the specified observer mapping
+             and resolves them to User objects.
+Parameters:
+    - mapping: Observer mapping to read from
+Returns:
+    - util::Map<std::string, User*>: Collection of observer records
+Throws:
+    - std::runtime_error if an observer references an invalid user ID
+*/
+util::Map<std::string, User*> DataStore::getObservers(MappingInfo& mapping)
+{
+    auto& users = getUsers();
+    util::Map<std::string, User*> observers;
+    SharedMemory::ensureLatestMapping(mapping);
+    size_t recordCount = SharedMemory::getRecordCount(mapping);
+    for (size_t index = 0; index < recordCount; index++)
+    {
+        const SerializedObserver* observer = static_cast<SerializedObserver*>(SharedMemory::getRecordAddress(mapping, index));
+        int userIndex = users.find(observer->id);
+        if (userIndex == -1)
+        {
+            throw std::runtime_error("Invalid observer user ID");
+        }
+        User* user = users.getValueAt(userIndex).data;
+        observers.insert(user->getId(), user);
+    }
+    return observers;
+}
+
 /*
 Function: getServiceManagementObservers
 Description: Retrieves all service management observer records from the datastore.
@@ -332,7 +534,7 @@ Returns:
 */
 util::Map<std::string, User*> DataStore::getServiceManagementObservers()
 {
-    return util::Map<std::string, User*>();
+    return getObservers(m_serviceManagementObservers);
 }

 /*
@@ -345,7 +547,7 @@ Returns:
 */
 util::Map<std::string, User*> DataStore::getPaymentManagementObservers()
 {
-    return util::Map<std::string, User*>();
+    return getObservers(m_paymentManagementObservers);
 }

 /*
@@ -358,7 +560,7 @@ Returns:
 */
 util::Map<std::string, User*> DataStore::getInventoryManagementObservers()
 {
-    return util::Map<std::string, User*>();
+    return getObservers(m_inventoryManagementObservers);
 }

 /*
@@ -371,6 +573,7 @@ Returns:
 */
 void DataStore::saveUsers()
 {
+    saveRecords<User, SerializedUser>(m_users, m_userCache);
 }

 /*
@@ -383,6 +586,7 @@ Returns:
 */
 void DataStore::saveNotifications()
 {
+    saveRecords<Notification, SerializedNotification>(m_notifications, m_notificationCache);
 }

 /*
@@ -395,6 +599,7 @@ Returns:
 */
 void DataStore::saveServices()
 {
+    saveRecords<Service, SerializedService>(m_services, m_serviceCache);
 }

 /*
@@ -407,6 +612,7 @@ Returns:
 */
 void DataStore::saveComboPackages()
 {
+    saveRecords<ComboPackage, SerializedComboPackage>(m_comboPackages, m_comboPackageCache);
 }

 /*
@@ -419,6 +625,7 @@ Returns:
 */
 void DataStore::saveInventoryItems()
 {
+    saveRecords<InventoryItem, SerializedInventoryItem>(m_inventoryItems, m_inventoryItemCache);
 }

 /*
@@ -431,6 +638,7 @@ Returns:
 */
 void DataStore::saveServiceBookings()
 {
+    saveRecords<ServiceBooking, SerializedServiceBooking>(m_serviceBookings, m_serviceBookingCache);
 }

 /*
@@ -443,6 +651,7 @@ Returns:
 */
 void DataStore::saveJobCards()
 {
+    saveRecords<JobCard, SerializedJobCard>(m_jobCards, m_jobCardCache);
 }

 /*
@@ -455,18 +664,52 @@ Returns:
 */
 void DataStore::saveInvoices()
 {
+    saveRecords<Invoice, SerializedInvoice>(m_invoices, m_invoiceCache);
+}
+
+/*
+Function: saveObservers
+Description: Persists observer records to the specified observer mapping.
+Parameters:
+    - mapping: MappingInfo&, observer mapping to save to
+    - observers: util::Map<std::string, User*>&, collection of observer records
+Returns:
+    - None
+*/
+void DataStore::saveObservers(MappingInfo& mapping, util::Map<std::string, User*>& observers)
+{
+    size_t observerCount = static_cast<size_t>(observers.getSize());
+    size_t capacity = config::file::INITIAL_CAPACITY;
+    while (capacity < observerCount)
+    {
+        capacity *= config::file::GROWTH_FACTOR;
+    }
+    if (!SharedMemory::resizeMapping(mapping, capacity))
+    {
+        throw std::runtime_error("Failed to resize observer mapping");
+    }
+    SharedMemory::setRecordCount(mapping, observerCount);
+    for (size_t index = 0; index < observerCount; index++)
+    {
+        SerializedObserver serializedObserver{};
+        User* user = observers.getValueAt(static_cast<int>(index));
+        strcpy_s(serializedObserver.id, sizeof(serializedObserver.id), user->getId().c_str());
+        SerializedObserver* destination = static_cast<SerializedObserver*>(SharedMemory::getRecordAddress(mapping, index));
+        *destination = serializedObserver;
+    }
 }

 /*
 Function: saveServiceManagementObservers
 Description: Persists all service management observer records to the datastore.
 Parameters:
-    - observers: util::Map<std::string, TrackedRecord<std::string>>&, collection of observer records
+    - observers: util::Map<std::string, User*>&, collection of observer records
 Returns:
    - None
 */
 void DataStore::saveServiceManagementObservers(util::Map<std::string, User*>& observers)
 {
+    saveObservers(m_serviceManagementObservers, observers);
 }

 /*
@@ -479,6 +722,7 @@ Returns:
 */
 void DataStore::savePaymentManagementObservers(util::Map<std::string, User*>& observers)
 {
+    saveObservers(m_paymentManagementObservers, observers);
 }

 /*
@@ -491,32 +735,7 @@ Returns:
 */
 void DataStore::saveInventoryManagementObservers(util::Map<std::string, User*>& observers)
 {
-}
-
-/*
-Function: lockDataStore
-Description: Acquires exclusive access to the datastore.
-Parameters:
-    - None
-Returns:
-    - bool: True if the datastore was successfully locked, otherwise false
-*/
-bool DataStore::lockDataStore()
-{
-    return false;
-}
-
-/*
-Function: unlockDataStore
-Description: Releases exclusive access to the datastore.
-Parameters:
-    - None
-Returns:
-    - bool: True if the datastore was successfully unlocked, otherwise false
-*/
-bool DataStore::unlockDataStore()
-{
-    return false;
+    saveObservers(m_inventoryManagementObservers, observers);
 }

 /*
@@ -561,5 +780,4 @@ bool DataStore::unlockDataStore()
        return false;
    }
    return ReleaseMutex(m_globalMutex) != 0;
-}
-
+}
@@ -11,15 +11,16 @@ Date: 19-May-2026
 #include "Map.h"
 #include "MappingInfo.h"
 #include "TrackedRecord.h"
+#include "SerializedRecords.h"
 #include "SharedMemory.h"
-class User;
-class Notification;
-class Service;
-class ComboPackage;
-class InventoryItem;
-class ServiceBooking;
-class JobCard;
-class Invoice;
+#include "User.h"
+#include "Notification.h"
+#include "Service.h"
+#include "ComboPackage.h"
+#include "InventoryItem.h"
+#include "ServiceBooking.h"
+#include "JobCard.h"
+#include "Invoice.h"

 class DataStore
 {
@@ -39,7 +40,6 @@ private:
    MappingInfo m_serviceBookings;
    MappingInfo m_jobCards;
    MappingInfo m_invoices;
-    MappingInfo m_payments;
    MappingInfo m_serviceManagementObservers;
    MappingInfo m_paymentManagementObservers;
    MappingInfo m_inventoryManagementObservers;
@@ -86,6 +86,8 @@ private:
    void saveRecords(MappingInfo& mapping, util::Map<std::string, TrackedRecord<TObject>>& records);
    template<typename TObject> void clearCache(util::Map<std::string, TrackedRecord<TObject>>&cache);
    template<typename TObject> void refreshCache(util::Map<std::string, TrackedRecord<TObject>>&cache, util::Map<std::string, TrackedRecord<TObject>>&refreshedCache);
+    util::Map<std::string, User*> getObservers(MappingInfo& mapping);
+    void saveObservers(MappingInfo& mapping, util::Map<std::string, User*>& observers);
 };

 /*
@@ -218,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;
@@ -229,9 +237,17 @@ void DataStore::refreshCache(util::Map<std::string, TrackedRecord<TObject>>& cac
    for (int index = 0; index < oldCache.getSize(); ++index)
    {
        const std::string& id = oldCache.getKeyAt(index);
+        const TrackedRecord<TObject>& localTrackedRecord = oldCache.getValueAt(index);
        if (cache.find(id) == -1)
        {
-            delete oldCache.getValueAt(index).data;
+            if (localTrackedRecord.state == RecordState::NEW_RECORD)
+            {
+                cache.insert(id, localTrackedRecord);
+            }
+            else
+            {
+                delete localTrackedRecord.data;
+            }
        }
    }
 }
@@ -0,0 +1,28 @@
+/*
+File: DataStoreLockGuard.h
+Description: Defines the DataStoreLockGuard class used to manage DataStore
+             locking and unlocking automatically within a scope.
+Author: Trenser
+Date: 12-June-2026
+*/
+
+#pragma once
+#include "DataStore.h"
+
+class DataStoreLockGuard
+{
+public:
+    explicit DataStoreLockGuard(DataStore& dataStore)
+        : m_dataStore(dataStore)
+    {
+        m_dataStore.lockDataStore();
+    }
+    ~DataStoreLockGuard()
+    {
+        m_dataStore.unlockDataStore();
+    }
+    DataStoreLockGuard(const DataStoreLockGuard&) = delete;
+    DataStoreLockGuard& operator=(const DataStoreLockGuard&) = delete;
+private:
+    DataStore& m_dataStore;
+};
@@ -12,7 +12,7 @@ Date: 19-May-2026
 #include "Enums.h"

 class Service;
-class SerializedComboPackage;
+struct SerializedComboPackage;

 class ComboPackage
 {
@@ -8,6 +8,7 @@ Date: 19-May-2026

 #include <sstream>
 #include <stdexcept>
+#include "SerializedRecords.h"
 #include "Factory.h"
 #include "StringHelper.h"
 #include "InventoryItem.h"
@@ -27,7 +28,8 @@ InventoryItem::InventoryItem()
    : m_id("IIM" + std::to_string(++m_uid)),
    m_quantity(0),
    m_status(util::State::ACTIVE),
-    m_price(0.0) {}
+    m_price(0.0) {
+}

 /*
 Function: InventoryItem
@@ -45,7 +47,8 @@ InventoryItem::InventoryItem(const std::string& partName, int quantity, double p
    m_partName(partName),
    m_quantity(quantity),
    m_status(util::State::ACTIVE),
-    m_price(price) {}
+    m_price(price) {
+}

 /*
 Function: InventoryItem (parameterized constructor with ID)
@@ -206,73 +209,37 @@ void InventoryItem::setState(util::State status)

 /*
 Function: serialize
-Description: Serializes the inventory item into a CSV-formatted string.
+Description: Serializes the InventoryItem object into a SerializedInventoryItem record.
 Parameters:
    - None
 Returns:
-    - std::string: Serialized inventory item record
+    - SerializedInventoryItem: Serialized representation of the inventory item
 */
-std::string InventoryItem::serialize() const
+SerializedInventoryItem InventoryItem::serialize() const
 {
-    std::ostringstream serializedInventoryItem;
-    serializedInventoryItem << m_id << ','
-        << m_partName << ','
-        << m_quantity << ','
-        << m_price << ','
-        << util::getStateString(m_status);
-    return serializedInventoryItem.str();
+    SerializedInventoryItem serialized = {};
+    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
+    strcpy_s(serialized.partName, sizeof(serialized.partName), m_partName.c_str());
+    serialized.quantity = m_quantity;
+    serialized.price = m_price;
+    serialized.status = m_status;
+    return serialized;
 }

 /*
 Function: deserialize
-Description: Deserializes a CSV-formatted string into an InventoryItem object.
+Description: Deserializes a SerializedInventoryItem record into an InventoryItem object.
 Parameters:
-    - record: const std::string&, serialized inventory item record
+    - serializedInventoryItem: const SerializedInventoryItem&, serialized inventory item record
 Returns:
    - InventoryItem*: Pointer to the deserialized InventoryItem object
-Throws:
-    - std::runtime_error if data is invalid
 */
-InventoryItem* InventoryItem::deserialize(const std::string& record)
+InventoryItem* InventoryItem::deserialize(const SerializedInventoryItem& serializedInventoryItem)
 {
-    std::string id, partName;
-    std::string quantityString, priceString, statusString;
-    int quantity;
-    double price;
-    std::istringstream serializedInventoryItem(record);
-    getline(serializedInventoryItem, id, ',');
-    getline(serializedInventoryItem, partName, ',');
-    getline(serializedInventoryItem, quantityString, ',');
-    getline(serializedInventoryItem, priceString, ',');
-    getline(serializedInventoryItem, statusString, ',');
-    try
-    {
-        quantity = std::stoi(quantityString);
-        price = std::stod(priceString);
-    }
-    catch (...)
-    {
-        throw std::runtime_error("Invalid inventory item data");
-    }
-    util::State status = util::getState(statusString);
    return Factory::getObject<InventoryItem>(
-        id,
-        partName,
-        quantity,
-        price,
-        status
-    );
-}
-
-/*
-Function: getHeaders
-Description: Retrieves the CSV headers for inventory item serialization.
-Parameters:
-    - None
-Returns:
-    - std::string: Header string ("ID,PartName,Quantity,Price,Status")
-*/
-std::string InventoryItem::getHeaders()
-{
-    return "ID,PartName,Quantity,Price,Status";
+        serializedInventoryItem.id,
+        serializedInventoryItem.partName,
+        serializedInventoryItem.quantity,
+        serializedInventoryItem.price,
+        serializedInventoryItem.status);
 }
@@ -6,11 +6,12 @@ Author: Trenser
 Date: 19-May-2026
 */

-
 #pragma once
 #include <string>
 #include "Enums.h"

+struct SerializedInventoryItem;
+
 class InventoryItem
 {
 private:
@@ -34,7 +35,6 @@ public:
    void setQuantity(int quantity);
    void setPrice(double price);
    void setState(util::State status);
-    std::string serialize() const;
-    static InventoryItem* deserialize(const std::string&);
-    static std::string getHeaders();
+    SerializedInventoryItem serialize() const;
+    static InventoryItem* deserialize(const SerializedInventoryItem&);
 };
@@ -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
@@ -57,16 +59,16 @@ Returns:
 Invoice::Invoice(
    const std::string& bookingId,
    ServiceBooking* booking,
-    const util::Timestamp& invoiceDate, 
-    double laborCost, 
+    const util::Timestamp& invoiceDate,
+    double laborCost,
    const util::Map<std::string, InventoryItem*>& parts,
    double partsCost,
-    double discountPercentage, 
-    double totalAmount, 
-    const util::Timestamp& paymentDate, 
-    util::PaymentMode paymentMethod, 
+    double discountPercentage,
+    double totalAmount,
+    const util::Timestamp& paymentDate,
+    util::PaymentMode paymentMethod,
    util::PaymentStatus status
-    )
+)
    : m_id("INV" + std::to_string(++m_uid)),
    m_bookingId(bookingId),
    m_booking(booking),
@@ -78,7 +80,7 @@ Invoice::Invoice(
    m_totalAmount(totalAmount),
    m_paymentDate(paymentDate),
    m_paymentMethod(paymentMethod),
-    m_status(status) 
+    m_status(status)
 {
    int numberOfParts = m_parts.getSize();
    auto partPointers = m_parts.getValues();
@@ -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);
 }
@@ -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
 {
@@ -39,14 +39,14 @@ public:
    Invoice(
        const std::string& bookingId,
        ServiceBooking* booking,
-        const util::Timestamp& invoiceDate, 
-        double laborCost, 
-        const util::Map<std::string,InventoryItem*>& parts,
+        const util::Timestamp& invoiceDate,
+        double laborCost,
+        const util::Map<std::string, InventoryItem*>& parts,
        double partsCost,
-        double discountPercentage, 
-        double totalAmount, 
-        const util::Timestamp& paymentDate, 
-        util::PaymentMode paymentMethod, 
+        double discountPercentage,
+        double totalAmount,
+        const util::Timestamp& paymentDate,
+        util::PaymentMode paymentMethod,
        util::PaymentStatus status
    );
    Invoice(
@@ -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&);
 };
@@ -1,12 +1,13 @@
 /*
 File: Notification.cpp
 Description: Implements the Notification class which represents system notifications in the Vehicle Service Management System.
-             Provides constructors, accessors, and mutators for notification details such as ID, recipient, title, message, and timestamp.
+             Provides constructors, accessors, and mutators for notification details such as ID, recipientID, title, message, and timestamp.
 Author: Trenser
 Date: 19-May-2026
 */

 #include <sstream>
+#include "SerializedRecords.h"
 #include "Notification.h"
 #include "StringHelper.h"
 #include "Factory.h"
@@ -22,8 +23,8 @@ Returns:
    - A new Notification object.
 */
 Notification::Notification()
-    : m_id("NOT" + std::to_string(++m_uid)),
-    m_recipient(nullptr) {}
+    : m_id("NOT" + std::to_string(++m_uid)), 
+    m_state(util::State::ACTIVE) {}

 /*
 Function: Notification
@@ -37,13 +38,14 @@ Parameters:
 Returns:
    - A new Notification object.
 */
-Notification::Notification(const std::string& recipientUserId, User* recipient, const std::string& title, const std::string& message, const util::Timestamp& createdAt)
+Notification::Notification(const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt)
    : m_id("NOT" + std::to_string(++m_uid)),
    m_recipientUserId(recipientUserId),
-    m_recipient(recipient),
    m_title(title),
    m_message(message),
-    m_createdAt(createdAt) {}
+    m_state(util::State::ACTIVE),
+    m_createdAt(createdAt) {
+}

 /*
 Function: Notification (parameterized constructor with ID)
@@ -58,13 +60,13 @@ Parameters:
 Returns:
    - A new Notification object
 */
-Notification::Notification(const std::string& id, const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt)
+Notification::Notification(const std::string& id, const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt, const util::State& state)
    : m_id(id),
    m_recipientUserId(recipientUserId),
-    m_recipient(nullptr),
    m_title(title),
    m_message(message),
-    m_createdAt(createdAt) 
+    m_createdAt(createdAt),
+    m_state(state)
 {
    int idNumber = util::extractNumber(m_id);
    if (idNumber > m_uid)
@@ -79,7 +81,7 @@ Description: Retrieves the unique ID of the notification.
 Returns:
    - const std::string& representing the notification ID.
 */
-const std::string& Notification::getId() const 
+const std::string& Notification::getId() const
 {
    return m_id;
 }
@@ -95,17 +97,6 @@ const std::string& Notification::getRecipientUserId() const
    return m_recipientUserId;
 }

-/*
-Function: getRecipient
-Description: Retrieves the pointer to the recipient user.
-Returns:
-    - User* representing the recipient.
-*/
-User* Notification::getRecipient() const
-{
-    return m_recipient;
-}
-
 /*
 Function: getTitle
 Description: Retrieves the title of the notification.
@@ -139,6 +130,17 @@ const util::Timestamp& Notification::getCreatedAt() const
    return m_createdAt;
 }

+/*
+Function: getState
+Description: Retrieves the Notification state
+Returns:
+    - const util::Timestamp& representing the creation timestamp.
+*/
+util::State Notification::getState() const
+{
+    return m_state;
+}
+
 /*
 Function: setId
 Description: Sets the unique ID of the notification.
@@ -165,19 +167,6 @@ void Notification::setRecipientUserId(const std::string& recipientUserId)
    m_recipientUserId = recipientUserId;
 }

-/*
-Function: setRecipient
-Description: Sets the recipient user pointer for the notification.
-Parameters:
-    - recipient: Pointer to the User object.
-Returns:
-    - void
-*/
-void Notification::setRecipient(User* recipient)
-{
-    m_recipient = recipient;
-}
-
 /*
 Function: setTitle
 Description: Sets the title of the notification.
@@ -217,71 +206,54 @@ void Notification::setCreatedAt(const util::Timestamp& createdAt)
    m_createdAt = createdAt;
 }

+/*
+Function: setState
+Description: Sets the Notification state.
+Parameters:
+    - state: Notification state value.
+Returns:
+    - void
+*/
+void Notification::setState(util::State state)
+{
+    m_state = state;
+}
+
 /*
 Function: serialize
-Description: Serializes the notification into a CSV-formatted string.
+Description: Serializes the Notification object into a SerializedNotification record.
 Parameters:
    - None
 Returns:
-    - std::string: Serialized notification record
+    - SerializedNotification: Serialized representation of the notification
 */
-std::string Notification::serialize() const
+SerializedNotification Notification::serialize() const
 {
-    std::ostringstream serializedNotification;
-    serializedNotification << m_id << ','
-        << m_recipientUserId << ','
-        << m_title << ','
-        << m_message << ','
-        << m_createdAt.toString();
-    return serializedNotification.str();
+    SerializedNotification serialized = {};
+    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
+    strcpy_s(serialized.recipientUserId, sizeof(serialized.recipientUserId), m_recipientUserId.c_str());
+    strcpy_s(serialized.title, sizeof(serialized.title), m_title.c_str());
+    strcpy_s(serialized.message, sizeof(serialized.message), m_message.c_str());
+    serialized.createdAt = m_createdAt;
+    serialized.state = m_state;
+    return serialized;
 }

 /*
 Function: deserialize
-Description: Deserializes a CSV-formatted string into a Notification object.
+Description: Deserializes a SerializedNotification record into a Notification object.
 Parameters:
-    - record: const std::string&, serialized notification record
+    - serializedNotification: const SerializedNotification&, serialized notification record
 Returns:
    - Notification*: Pointer to the deserialized Notification object
-Throws:
-    - std::runtime_error if timestamp parsing fails
 */
-Notification* Notification::deserialize(const std::string& record)
+Notification* Notification::deserialize(const SerializedNotification& serializedNotification)
 {
-    std::string id, recipientUserId, title, message, createdAtTimestampString;
-    std::istringstream serializedNotification(record);
-    getline(serializedNotification, id, ',');
-    getline(serializedNotification, recipientUserId, ',');
-    getline(serializedNotification, title, ',');
-    getline(serializedNotification, message, ',');
-    getline(serializedNotification, createdAtTimestampString, ',');
-    util::Timestamp createdAtTimestamp;
-    try
-    {
-        createdAtTimestamp = util::Timestamp::fromString(createdAtTimestampString);
-    }
-    catch (...)
-    {
-        throw std::runtime_error("Invalid createdAt timestamp");
-    }
    return Factory::getObject<Notification>(
-        id,
-        recipientUserId,
-        title,
-        message,
-        createdAtTimestamp
-    );
-}
-
-/*
-Function: getHeaders
-Description: Retrieves the CSV headers for notification serialization.
-Parameters:
-    - None
-Returns:
-    - std::string: Header string ("ID,RecipientID,Title,Message,Timestamp")
-*/
-std::string Notification::getHeaders()
-{
-    return "ID,RecipientID,Title,Message,Timestamp";
+        serializedNotification.id,
+        serializedNotification.recipientUserId,
+        serializedNotification.title,
+        serializedNotification.message,
+        serializedNotification.createdAt,
+        serializedNotification.state);
 }
@@ -9,8 +9,10 @@ Date: 19-May-2026
 #pragma once
 #include <string>
 #include "Timestamp.h"
+#include "Enums.h"

 class User;
+struct SerializedNotification;

 class Notification
 {
@@ -18,27 +20,26 @@ private:
    static int m_uid;
    std::string m_id;
    std::string m_recipientUserId;
-    User* m_recipient;
    std::string m_title;
    std::string m_message;
    util::Timestamp m_createdAt;
+    util::State m_state;
 public:
    Notification();
-    Notification(const std::string& recipientUserId, User* recipient, const std::string& title, const std::string& message, const util::Timestamp& createdAt);
-    Notification(const std::string& id, const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt);
+    Notification(const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt);
+    Notification(const std::string& id, const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt, const util::State& state);
    const std::string& getId() const;
    const std::string& getRecipientUserId() const;
-    User* getRecipient() const;
    const std::string& getTitle() const;
    const std::string& getMessage() const;
    const util::Timestamp& getCreatedAt() const;
    void setId(const std::string& id);
    void setRecipientUserId(const std::string& recipientUserId);
-    void setRecipient(User* recipient);
    void setTitle(const std::string& title);
    void setMessage(const std::string& message);
    void setCreatedAt(const util::Timestamp& createdAt);
-    std::string serialize() const;
-    static Notification* deserialize(const std::string&);
-    static std::string getHeaders();
+    util::State getState() const;
+    void setState(util::State state);
+    SerializedNotification serialize() const;
+    static Notification* deserialize(const SerializedNotification&);
 };
@@ -8,6 +8,7 @@ Date: 19-May-2026
 */

 #include <sstream>
+#include "SerializedRecords.h"
 #include "User.h"
 #include "Notification.h"
 #include "Enums.h"
@@ -28,7 +29,8 @@ Returns:
 User::User()
    : m_id("USR" + std::to_string(++m_uid)),
    m_type(util::UserType::CUSTOMER),
-    m_status(util::State::ACTIVE) {}
+    m_status(util::State::ACTIVE) {
+}

 /*
 Function: User
@@ -51,7 +53,8 @@ User::User(const std::string& userName, const std::string& password, const std::
    m_phone(phone),
    m_email(email),
    m_type(role),
-    m_status(util::State::ACTIVE) {}
+    m_status(util::State::ACTIVE) {
+}

 /*
 Function: User (parameterized constructor with ID)
@@ -86,23 +89,6 @@ User::User(const std::string& userId, const std::string& userName, const std::st
    }
 }

-/*
-Function: ~User
-Description: Destructor that cleans up dynamically allocated notifications associated with the user.
-Parameters:
-    - None
-Returns:
-    - void
-*/
-User::~User()
-{
-    auto values = m_notifications.getValues();
-    for (int index = 0; index < values.getSize(); index++)
-    {
-        delete values[index];
-    }
-}
-
 /*
 Function: getId
 Description: Retrieves the unique ID of the user.
@@ -169,17 +155,6 @@ const std::string& User::getEmail() const
    return m_email;
 }

-/*
-Function: getNotifications
-Description: Retrieves the map of notifications associated with the user.
-Returns:
-    - util::Map<std::string, Notification*>& representing the notifications.
-*/
-util::Map<std::string, Notification*>& User::getNotifications()
-{
-    return m_notifications;
-}
-
 /*
 Function: getUserType
 Description: Retrieves the role of the user.
@@ -280,22 +255,6 @@ void User::setEmail(const std::string& email)
    m_email = email;
 }

-/*
-Function: addNotification
-Description: Adds a new notification to the user’s notification map.
-Parameters:
-    - notification: Pointer to the Notification object.
-Returns:
-    - void
-*/
-void User::addNotification(Notification* notification)
-{
-    if (notification)
-    {
-        m_notifications.insert(notification->getId(), notification);
-    }
-}
-
 /*
 Function: setRole
 Description: Sets the role of the user.
@@ -324,68 +283,43 @@ void User::setState(util::State status)

 /*
 Function: serialize
-Description: Serializes the user into a CSV-formatted string.
+Description: Serializes the User object into a SerializedUser record.
 Parameters:
    - None
 Returns:
-    - std::string: Serialized user record
+    - SerializedUser: Serialized representation of the user
 */
-std::string User::serialize() const
+SerializedUser User::serialize() const
 {
-    std::ostringstream serializedUser;
-    serializedUser << m_id << ','
-        << m_userName << ','
-        << m_password << ','
-        << m_name << ','
-        << m_phone << ','
-        << m_email << ','
-        << util::getUserTypeString(m_type) << ','
-        << util::getStateString(m_status);
-    return serializedUser.str();
+    SerializedUser serialized = {};
+    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
+    strcpy_s(serialized.username, sizeof(serialized.username), m_userName.c_str());
+    strcpy_s(serialized.password, sizeof(serialized.password), m_password.c_str());
+    strcpy_s(serialized.name, sizeof(serialized.name), m_name.c_str());
+    strcpy_s(serialized.phone, sizeof(serialized.phone), m_phone.c_str());
+    strcpy_s(serialized.email, sizeof(serialized.email), m_email.c_str());
+    serialized.userType = m_type;
+    serialized.status = m_status;
+    return serialized;
 }

 /*
 Function: deserialize
-Description: Deserializes a CSV-formatted string into a User object.
+Description: Deserializes a SerializedUser record into a User object.
 Parameters:
-    - record: const std::string&, serialized user record
+    - serializedUser: const SerializedUser&, serialized user record
 Returns:
    - User*: Pointer to the deserialized User object
 */
-User* User::deserialize(const std::string& record)
+User* User::deserialize(const SerializedUser& serializedUser)
 {
-    std::string id, name, username, phone, password, email;
-    std::string userTypeString, stateString;
-    std::istringstream serializedUser(record);
-    getline(serializedUser, id, ',');
-    getline(serializedUser, username, ',');
-    getline(serializedUser, password, ',');
-    getline(serializedUser, name, ',');
-    getline(serializedUser, phone, ',');
-    getline(serializedUser, email, ',');
-    getline(serializedUser, userTypeString, ',');
-    getline(serializedUser, stateString);
-    util::UserType userType = util::getUserType(userTypeString);
-    util::State status = util::getState(stateString);
-    return Factory::getObject<User>(id,
-        username,
-        password,
-        name,
-        phone,
-        email,
-        userType,
-        status);
-}
-
-/*
-Function: getHeaders
-Description: Retrieves the CSV headers for user serialization.
-Parameters:
-    - None
-Returns:
-    - std::string: Header string ("ID,Username,Password,Name,Phone,Email,UserType,UserStatus")
-*/
-std::string User::getHeaders()
-{
-    return "ID,Username,Password,Name,Phone,Email,UserType,UserStatus";
+    return Factory::getObject<User>(
+        serializedUser.id,
+        serializedUser.username,
+        serializedUser.password,
+        serializedUser.name,
+        serializedUser.phone,
+        serializedUser.email,
+        serializedUser.userType,
+        serializedUser.status);
 }
@@ -14,6 +14,7 @@ Date: 19-May-2026
 #include "Enums.h"

 class Notification;
+struct SerializedUser;

 class User : public Observer
 {
@@ -25,21 +26,19 @@ private:
    std::string m_name;
    std::string m_phone;
    std::string m_email;
-    util::Map<std::string, Notification*> m_notifications;
    util::UserType m_type;
    util::State m_status;
 public:
    User();
    User(const std::string& userName, const std::string& password, const std::string& name, const std::string& phone, const std::string& email, util::UserType role);
    User(const std::string& userId, const std::string& userName, const std::string& password, const std::string& name, const std::string& phone, const std::string& email, util::UserType role, util::State status);
-    ~User();
+    ~User() = default;
    const std::string& getId() const;
    const std::string& getUserName() const;
    const std::string& getPassword() const;
    const std::string& getName() const;
    const std::string& getPhone() const;
    const std::string& getEmail() const;
-    util::Map<std::string, Notification*>& getNotifications();
    util::UserType getUserType() const;
    util::State getState() const;
    void setId(const std::string& id);
@@ -48,10 +47,8 @@ public:
    void setName(const std::string& name);
    void setPhone(const std::string& phone);
    void setEmail(const std::string& email);
-    void addNotification(Notification* notification) override;
    void setRole(util::UserType role);
    void setState(util::State status);
-    std::string serialize() const;
-    static User* deserialize(const std::string&);
-    static std::string getHeaders();
+    SerializedUser serialize() const;
+    static User* deserialize(const SerializedUser& serializedUser);
 };
@@ -10,8 +10,32 @@ Date:19-May-2026
 #include <stdexcept>
 #include "AuthenticationManagementService.h"
 #include "User.h"
+#include "Utility.h"
+#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
@@ -24,16 +48,35 @@ Return type: bool - true if login successful, false otherwise
 */
 bool AuthenticationManagementService::login(const std::string& username, const std::string& password)
 {
-	util::Map<std::string, User*> users = m_dataStore.getUsers();
-	int usersMapSize = users.getSize();
-	for (int index = 0; index < usersMapSize; index++)
+	DataStoreLockGuard lock(m_dataStore);
+	auto& trackedUserMap = m_dataStore.getUsers();
+	int trackedUserMapSize = trackedUserMap.getSize();
+	for (int index = 0; index < trackedUserMapSize; index++)
 	{
-		User* user = users.getValueAt(index);
+		User* user = trackedUserMap.getValueAt(index).data;
 		if (username == user->getUserName())
 		{
 			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;
@@ -62,7 +105,11 @@ Return type: void
 */
 void AuthenticationManagementService::logout()
 {
+	m_eventManager.shutdown();
 	m_authenticatedUser = nullptr;
+	m_isAuthorized = false;
+	m_accountDisabledEvent = NULL;
+	m_notificationsAvailableEvent = NULL;
 }

 /*
@@ -74,9 +121,33 @@ 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)
 	{
 		throw std::runtime_error("There is no user currently logged in!");
 	}
+	int index = trackedUsersMap.find(m_authenticatedUser->getId());
+	if (index == -1)
+	{
+		throw std::runtime_error("User does not exist!\n");
+	}
 	m_authenticatedUser->setPassword(newPassword);
+	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;
 }
@@ -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);
 };
@@ -12,14 +12,15 @@ Date: 22-May-2026
 #include "Config.h"
 #include "Enums.h"
 #include "Factory.h"
-#include "FileManager.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{};

@@ -58,18 +59,19 @@ Returns:
 */
 void InventoryManagementService::sendLowStockAlerts()
 {
-	auto& inventoryItems = m_dataStore.getInventoryItems();
-	if (inventoryItems.isEmpty())
+	DataStoreLockGuard lock(m_dataStore);
+	auto& trackedInventoryItemsMap = m_dataStore.getInventoryItems();
+	auto& trackedUserMap = m_dataStore.getUsers();
+	if (trackedInventoryItemsMap.isEmpty())
 	{
 		return;
 	}
-	int inventoryItemsSize = inventoryItems.getSize();
-	auto& usersMap = m_dataStore.getUsers();
-	int usersMapSize = usersMap.getSize();
+	int inventoryItemsSize = trackedInventoryItemsMap.getSize();
+	int usersMapSize = trackedUserMap.getSize();
 	util::Vector<User*> adminUsers;
 	for (int index = 0; index < usersMapSize; index++)
 	{
-		User* user = usersMap.getValueAt(index);
+		User* user = trackedUserMap.getValueAt(index).data;
 		if (user->getUserType() == util::UserType::ADMIN)
 		{
 			adminUsers.push_back(user);
@@ -82,7 +84,7 @@ void InventoryManagementService::sendLowStockAlerts()
 	}
 	for (int index = 0; index < inventoryItemsSize; index++)
 	{
-		InventoryItem* inventoryItem = inventoryItems.getValueAt(index);
+		InventoryItem* inventoryItem = trackedInventoryItemsMap.getValueAt(index).data;
 		if (inventoryItem && inventoryItem->getQuantity() < config::threshold::INVENTORY_LOW_STOCK_THRESHOLD)
 		{
 			sendLowStockAlertsToAdmins(*this, inventoryItem, adminUsers);
@@ -90,95 +92,6 @@ void InventoryManagementService::sendLowStockAlerts()
 	}
 }

-/*
-Function: getObserverIDs
-Description: Retrieves the IDs of all observers currently attached to the
-			 InventoryManagementService.
-Parameters:
-	- None
-Returns:
-	- util::Vector<std::string>: Vector of observer user IDs
-*/
-util::Vector<std::string> InventoryManagementService::getObserverIDs()
-{
-	util::Vector<std::string> observerIDs;
-	int numberOfObservers = m_observers.getSize();
-	for (int index = 0; index < numberOfObservers; index++)
-	{
-		User* observer = m_observers.getValueAt(index);
-		if (observer)
-		{
-			observerIDs.push_back(observer->getId());
-		}
-	}
-	return observerIDs;
-}
-
-/*
-Function: loadInventoryItems
-Description: Loads inventory items from persistent storage into the datastore.
-			 Uses FileManager to deserialize inventory items from the configured file.
-Parameters:
-	- None
-Returns:
-	- void
-*/
-void InventoryManagementService::loadInventoryItems()
-{
-	util::FileManager<InventoryItem> inventoryItemFileManager(config::file::INVENTORYITEM_FILE);
-	auto& inventoryItems = m_dataStore.getInventoryItems();
-	auto inventoryItemsMap = inventoryItemFileManager.load();
-	int numberOfInventoryItems = inventoryItemsMap.getSize();
-	for (int index = 0; index < numberOfInventoryItems; index++)
-	{
-		inventoryItems[inventoryItemsMap.getKeyAt(index)] = inventoryItemsMap.getValueAt(index);
-	}
-}
-
-/*
-Function: saveInventoryItems
-Description: Saves inventory items from the datastore to persistent storage.
-			 Uses FileManager to serialize inventory items into the configured file.
-Parameters:
-	- None
-Returns:
-	- void
-*/
-void InventoryManagementService::saveInventoryItems()
-{
-	util::FileManager<InventoryItem> inventoryItemFileManager(config::file::INVENTORYITEM_FILE);
-	auto& inventoryItems = m_dataStore.getInventoryItems();
-	inventoryItemFileManager.save(inventoryItems);
-}
-
-/*
-Function: loadObservers
-Description: Loads observer IDs from persistent storage and attaches corresponding
-			 users as observers to the InventoryManagementService.
-Parameters:
-	- None
-Returns:
-	- void
-*/
-void InventoryManagementService::loadObservers()
-{
-	util::loadObservers(config::file::INVENTORYMANAGEMENTOBSERVERS, this, m_dataStore);
-}
-
-/*
-Function: saveObservers
-Description: Saves the current observer IDs of the InventoryManagementService
-			 to persistent storage for future retrieval.
-Parameters:
-	- None
-Returns:
-	- void
-*/
-void InventoryManagementService::saveObservers()
-{
-	util::saveObservers(config::file::INVENTORYMANAGEMENTOBSERVERS, this);
-}
-
 /*
 Function: addInventoryItem
 Description: Creates a new inventory item using the Factory and inserts it
@@ -190,8 +103,12 @@ 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);
-    m_dataStore.getInventoryItems().insert(newItem->getId(), newItem);
+	trackedInventoryItemMap.insert(newItem->getId(), util::createNewRecord(newItem));
+	m_dataStore.saveInventoryItems();
 }

 /*
@@ -203,16 +120,23 @@ Return type: void
 */
 void InventoryManagementService::addInventoryItemStock(const std::string& selectedItemId, int quantity)
 {
-    int index = m_dataStore.getInventoryItems().find(selectedItemId);
-    if (index != -1)
-    {
-        InventoryItem* item = m_dataStore.getInventoryItems().getValueAt(index);
-        if (item != nullptr)
-        {
-            int totalQuantity = item->getQuantity() + quantity;
-            item->setQuantity(totalQuantity);
-        }
-    }
+    AuthenticationManagementService::ensureAuthorization();
+	DataStoreLockGuard lock(m_dataStore);
+	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
+	int index = trackedInventoryItemMap.find(selectedItemId);
+	if (index == -1)
+	{
+		throw std::runtime_error("Inventory update failed: Item ID '" + selectedItemId + "' not found.");
+	}
+	InventoryItem* item = trackedInventoryItemMap.getValueAt(index).data;
+	if (item == nullptr)
+	{
+		throw std::runtime_error("Inventory update failed. Item does not exist.\n");
+	}
+	int totalQuantity = item->getQuantity() + quantity;
+	item->setQuantity(totalQuantity);
+	trackedInventoryItemMap.getValueAt(index).state = RecordState::MODIFIED;
+	m_dataStore.saveInventoryItems();
 }

 /*
@@ -223,7 +147,11 @@ Return type: util::Map<std::string, InventoryItem*>
 */
 util::Map<std::string, InventoryItem*> InventoryManagementService::getInventoryItems()
 {
-	return m_dataStore.getInventoryItems();
+    AuthenticationManagementService::ensureAuthorization();
+	DataStoreLockGuard lock(m_dataStore);
+	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
+	auto inventoryMap = util::getObjects(trackedInventoryItemMap);
+	return inventoryMap;
 }

 /*
@@ -234,15 +162,22 @@ Return type: void
 */
 void InventoryManagementService::removeInventoryItem(const std::string& inventoryItemID)
 {
-    int index = m_dataStore.getInventoryItems().find(inventoryItemID);
-    if (index != -1)
-    {
-        InventoryItem* item = m_dataStore.getInventoryItems().getValueAt(index);
-        if (item != nullptr)
-        {
-            item->setState(util::State::INACTIVE);
-        }
-    }
+    AuthenticationManagementService::ensureAuthorization();
+	DataStoreLockGuard lock(m_dataStore);
+	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
+	int index = trackedInventoryItemMap.find(inventoryItemID);
+	if (index == -1)
+	{
+		throw std::runtime_error("Inventory removal failed: Item ID '" + inventoryItemID + "' not found.");
+	}
+	InventoryItem* item = trackedInventoryItemMap.getValueAt(index).data;
+	if (item == nullptr)
+	{
+		throw std::runtime_error("Inventory removal failed: Item ID does not exist.");
+	}
+	item->setState(util::State::INACTIVE);
+	trackedInventoryItemMap.getValueAt(index).state = RecordState::MODIFIED;
+	m_dataStore.saveInventoryItems();
 }

 /*
@@ -253,12 +188,20 @@ Return type: InventoryItem*
 */
 InventoryItem* InventoryManagementService::getInventoryItem(const std::string& inventoryItemID)
 {
-    int index = m_dataStore.getInventoryItems().find(inventoryItemID);
-    if (index != -1)
+    AuthenticationManagementService::ensureAuthorization();
+	DataStoreLockGuard lock(m_dataStore);
+	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
+    int index = trackedInventoryItemMap.find(inventoryItemID);
+    if (index == -1)
    {
-        return m_dataStore.getInventoryItems().getValueAt(index);
+		return nullptr;
    }
-    return nullptr;
+	InventoryItem* inventoryItem = trackedInventoryItemMap.getValueAt(index).data;
+	if (inventoryItem == nullptr)
+	{
+		throw std::runtime_error("Item ID does not exist.");
+	}
+	return inventoryItem;
 }

 /*
@@ -271,6 +214,9 @@ Returns:
 */
 void InventoryManagementService::attach(User* user)
 {
+	DataStoreLockGuard lock(m_dataStore);
+	m_observers.clear();
+	m_observers = m_dataStore.getInventoryManagementObservers();
 	if (user)
 	{
 		const std::string& userID = user->getId();
@@ -279,6 +225,7 @@ void InventoryManagementService::attach(User* user)
 			m_observers[userID] = user;
 		}
 	}
+	m_dataStore.saveInventoryManagementObservers(m_observers);
 }

 /*
@@ -291,6 +238,9 @@ Returns:
 */
 void InventoryManagementService::detach(User* user)
 {
+	DataStoreLockGuard lock(m_dataStore);
+	m_observers.clear();
+	m_observers = m_dataStore.getInventoryManagementObservers();
 	if (user)
 	{
 		const std::string& userID = user->getId();
@@ -299,6 +249,7 @@ void InventoryManagementService::detach(User* user)
 			m_observers.remove(userID);
 		}
 	}
+	m_dataStore.saveInventoryManagementObservers(m_observers);
 }

 /*
@@ -315,27 +266,28 @@ Throws:
 */
 void InventoryManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
 {
-	if (user)
+	if (!user)
 	{
-		if (m_observers.find(user->getId()) != -1)
-		{
-			Notification* notification =
-				Factory::getObject<Notification>(
-					user->getId(),
-					user,
-					title,
-					message,
-					util::Timestamp()
-				);
-			if (notification)
-			{
-				user->addNotification(notification);
-			}
-			else
-			{
-				throw std::runtime_error("Failed to create notification");
-			}
-		}
+		return;
 	}
+	DataStoreLockGuard lock(m_dataStore);
+	m_observers = m_dataStore.getInventoryManagementObservers();
+	if (m_observers.find(user->getId()) == -1)
+	{
+		return;
+	}
+	auto& trackedNotificationsMap = m_dataStore.getNotifications();
+	Notification* notification = Factory::getObject<Notification>(
+		user->getId(),
+		title,
+		message,
+		util::Timestamp());
+	if (!notification)
+	{
+		throw std::runtime_error("Failed to create notification");
+	}
+	trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
+	m_dataStore.saveNotifications();
+	EventManager::sendNotificationAvailableEvent(user->getId());
 }

@@ -21,7 +21,6 @@ class InventoryManagementService : public NotificationManagementService
 private:
    DataStore& m_dataStore;
    static util::Map<std::string, User*> m_observers;
-    util::Vector<std::string> getObserverIDs() override;
 public:
    InventoryManagementService() : m_dataStore(DataStore::getInstance()) {}
    util::Map<std::string, InventoryItem*> getInventoryItems();
@@ -33,8 +32,4 @@ public:
    void sendNotification(User* user, const std::string& title, const std::string& message) override;
    void attach(User* user) override;
    void detach(User* user) override;
-    void loadInventoryItems();
-    void saveInventoryItems();
-    void loadObservers();
-    void saveObservers();
 };
@@ -1 +0,0 @@
-#include "NotificationManagementService.h"
@@ -19,5 +19,4 @@ public:
 	virtual void sendNotification(User* recipient, const std::string& title, const std::string& message) = 0;
 	virtual void attach(User* user) = 0;
 	virtual void detach(User* user) = 0;
-	virtual util::Vector<std::string> getObserverIDs() = 0;
 };
@@ -11,16 +11,19 @@ Date: 20-May-2026
 #include "Config.h"
 #include "Enums.h"
 #include "Factory.h"
-#include "FileManager.h"
 #include "InventoryItem.h"
 #include "Invoice.h"
 #include "JobCard.h"
 #include "PaymentManagementService.h"
+#include "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{};

@@ -34,6 +37,9 @@ Returns:
 */
 void PaymentManagementService::attach(User* user)
 {
+	DataStoreLockGuard lock(m_dataStore);
+	m_observers.clear();
+	m_observers = m_dataStore.getPaymentManagementObservers();
 	if (user)
 	{
 		const std::string& userID = user->getId();
@@ -42,6 +48,7 @@ void PaymentManagementService::attach(User* user)
 			m_observers[userID] = user;
 		}
 	}
+	m_dataStore.savePaymentManagementObservers(m_observers);
 }

 /*
@@ -54,6 +61,9 @@ Returns:
 */
 void PaymentManagementService::detach(User* user)
 {
+	DataStoreLockGuard lock(m_dataStore);
+	m_observers.clear();
+	m_observers = m_dataStore.getPaymentManagementObservers();
 	if (user)
 	{
 		const std::string& userID = user->getId();
@@ -62,6 +72,7 @@ void PaymentManagementService::detach(User* user)
 			m_observers.remove(userID);
 		}
 	}
+	m_dataStore.savePaymentManagementObservers(m_observers);
 }

 /*
@@ -78,28 +89,29 @@ Throws:
 */
 void PaymentManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
 {
-	if (user)
+	if (!user)
 	{
-		if (m_observers.find(user->getId()) != -1)
-		{
-			Notification* notification =
-				Factory::getObject<Notification>(
-					user->getId(),
-					user,
-					title,
-					message,
-					util::Timestamp()
-				);
-			if (notification)
-			{
-				user->addNotification(notification);
-			}
-			else
-			{
-				throw std::runtime_error("Failed to create notification");
-			}
-		}
+		return;
 	}
+	DataStoreLockGuard lock(m_dataStore);
+	m_observers = m_dataStore.getPaymentManagementObservers();
+	if (m_observers.find(user->getId()) == -1)
+	{
+		return;
+	}
+	auto& trackedNotificationsMap = m_dataStore.getNotifications();
+	Notification* notification = Factory::getObject<Notification>(
+		user->getId(),
+		title,
+		message,
+		util::Timestamp());
+	if (!notification)
+	{
+		throw std::runtime_error("Failed to create notification");
+	}
+	trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
+	m_dataStore.saveNotifications();
+	EventManager::sendNotificationAvailableEvent(user->getId());
 }

 /*
@@ -113,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();
@@ -140,123 +153,6 @@ void PaymentManagementService::sendPaymentReminders()
 	}
 }

-/*
-Function: getObserverIDs
-Description: Retrieves the IDs of all observers currently attached to the
-             PaymentManagementService.
-Parameters:
-    - None
-Returns:
-    - util::Vector<std::string>: Vector of observer user IDs
-*/
-util::Vector<std::string> PaymentManagementService::getObserverIDs()
-{
-	util::Vector<std::string> observerIDs;
-	int numberOfObservers = m_observers.getSize();
-	for (int index = 0; index < numberOfObservers; index++)
-	{
-		User* observer = m_observers.getValueAt(index);
-		if (observer)
-		{
-			observerIDs.push_back(observer->getId());
-		}
-	}
-	return observerIDs;
-}
-
-/*
-Function: loadInvoices
-Description: Loads invoices from persistent storage into the datastore.
-             Validates associated service bookings and inventory parts before
-             attaching them to each invoice. Throws exceptions if invalid IDs
-             are encountered.
-Parameters:
-    - None
-Returns:
-    - void
-Throws:
-    - std::runtime_error if a booking ID or part ID is invalid
-*/
-void PaymentManagementService::loadInvoices()
-{
-    util::FileManager<Invoice> invoiceFileManager(config::file::INVOICE_FILE);
-    auto& invoices = m_dataStore.getInvoices();
-    auto& serviceBookings = m_dataStore.getServiceBookings();
-    auto& inventoryItems = m_dataStore.getInventoryItems();
-    auto invoicesMap = invoiceFileManager.load();
-    for (int invoiceIndex = 0; invoiceIndex < invoicesMap.getSize(); invoiceIndex++)
-    {
-        Invoice* invoice = invoicesMap.getValueAt(invoiceIndex);
-        int bookingIndex = serviceBookings.find(invoice->getBookingId());
-        if (bookingIndex == -1)
-        {
-            throw std::runtime_error("Invalid Booking ID");
-        }
-        ServiceBooking* booking = serviceBookings.getValueAt(bookingIndex);
-        invoice->setBooking(booking);
-        util::Map<std::string, InventoryItem*> invoiceParts;
-        auto& partIDs = invoice->getPartIDs();
-        for (int partIndex = 0; partIndex < partIDs.getSize(); partIndex++)
-        {
-            const std::string& partID = partIDs[partIndex];
-            int inventoryIndex = inventoryItems.find(partID);
-            if (inventoryIndex == -1)
-            {
-                throw std::runtime_error("Invalid Part ID");
-            }
-            invoiceParts[partID] = inventoryItems.getValueAt(inventoryIndex);
-        }
-        invoice->setParts(invoiceParts);
-        invoices[invoice->getId()] = invoice;
-    }
-}
-
-/*
-Function: saveInvoices
-Description: Saves invoices from the datastore to persistent storage.
-             Uses FileManager to serialize invoices into the configured file.
-Parameters:
-    - None
-Returns:
-    - void
-*/
-void PaymentManagementService::saveInvoices()
-{
-    util::FileManager<Invoice> invoiceFileManager(config::file::INVOICE_FILE);
-    auto& invoices = m_dataStore.getInvoices();
-    invoiceFileManager.save(invoices);
-}
-
-/*
-Function: loadObservers
-Description: Loads observer IDs from persistent storage and attaches corresponding
-             users as observers to the PaymentManagementService.
-Parameters:
-    - None
-Returns:
-    - void
-Throws:
-    - std::runtime_error if an observer ID is invalid (not found in datastore)
-*/
-void PaymentManagementService::loadObservers()
-{
-    util::loadObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this, m_dataStore);
-}
-
-/*
-Function: saveObservers
-Description: Saves the current observer IDs of the PaymentManagementService
-             to persistent storage for future retrieval.
-Parameters:
-    - None
-Returns:
-    - void
-*/
-void PaymentManagementService::saveObservers()
-{
-    util::saveObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this);
-}
-
 /*
 Function: createInventoryItemsMap (static helper)
 Description: Builds a map of inventory items required for a given service and adds them to the booking’s inventory map.
@@ -290,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.");
@@ -299,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)
 		{
@@ -322,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();
 }

 /*
@@ -336,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);
@@ -363,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();
@@ -378,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;
 }

 /*
@@ -412,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();
 }
@@ -22,20 +22,15 @@ class PaymentManagementService : public NotificationManagementService
 private:
    DataStore& m_dataStore;
    static util::Map<std::string, User*> m_observers;
-    util::Vector<std::string> getObserverIDs() override;
 public:
    PaymentManagementService() : m_dataStore(DataStore::getInstance()) {}
    void generateInvoice(ServiceBooking* booking);
    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;
    void attach(User* user) override;
    void detach(User* user) override;
-    void loadInvoices();
-    void saveInvoices();
-    void loadObservers();
-    void saveObservers();
 };
@@ -23,7 +23,6 @@ class ServiceManagementService : public NotificationManagementService
 private:
    DataStore& m_dataStore;
    static util::Map<std::string, User*> m_observers;
-    util::Vector<std::string> getObserverIDs() override;
 public:
    ServiceManagementService() : m_dataStore(DataStore::getInstance()) {}
    util::Map<std::string, Service*> getServices();
@@ -36,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);
@@ -45,14 +45,4 @@ public:
    void sendNotification(User* user, const std::string& title, const std::string& message) override;
    void attach(User* user) override;
    void detach(User* user) override;
-    void loadServices();
-    void saveServices();
-    void loadComboPackages();
-    void saveComboPackages();
-    void loadServiceBookings();
-    void saveServiceBookings();
-    void loadJobCards();
-    void saveJobCards();
-    void loadObservers();
-    void saveObservers();
 };
@@ -11,15 +11,19 @@ Date:19-May-2026
 #include "Config.h"
 #include "Enums.h"
 #include "Factory.h"
-#include "FileManager.h"
 #include "InventoryManagementService.h"
 #include "Notification.h"
 #include "PaymentManagementService.h"
 #include "ServiceManagementService.h"
+#include "AuthenticationManagementService.h"
 #include "User.h"
 #include "UserManagementService.h"
 #include "Vector.h"
 #include "Validator.h"
+#include "Utility.h"
+#include "TrackedRecord.h"
+#include "DataStoreLockGuard.h"
+#include "EventManager.h"

 /*
 Function: ensureAdminExists
@@ -31,12 +35,13 @@ Return type: void
 */
 void UserManagementService::ensureAdminExists()
 {
+	DataStoreLockGuard lock(m_dataStore);
 	auto& usersMap = m_dataStore.getUsers();
 	int usersMapSize = usersMap.getSize();
 	bool isAdminFound = false;
 	for (int index = 0; index < usersMapSize; index++)
 	{
-		User* user = usersMap.getValueAt(index);
+		User* user = usersMap.getValueAt(index).data;
 		if (user && user->getUserType() == util::UserType::ADMIN)
 		{
 			isAdminFound = true;
@@ -73,7 +78,9 @@ void UserManagementService::createUser(const std::string& username, const std::s
 	InventoryManagementService inventoryManagementService;
 	PaymentManagementService paymentManagementService;
 	ServiceManagementService serviceManagementService;
-	auto& usersMap = m_dataStore.getUsers();
+	DataStoreLockGuard lock(m_dataStore);
+	auto& trackedUsersMap = m_dataStore.getUsers();
+	auto usersMap = util::getObjects(trackedUsersMap);
 	if (util::isUsernameDuplicate(username, usersMap))
 	{
 		throw std::runtime_error("Username already exists");
@@ -87,13 +94,14 @@ void UserManagementService::createUser(const std::string& username, const std::s
 		throw std::runtime_error("Phone already exists");
 	}
 	User* newUser = Factory::getObject<User>(username, password, name, phone, email, type);
-	usersMap.insert(newUser->getId(), newUser);
+	trackedUsersMap.insert(newUser->getId(), util::createNewRecord(newUser));
 	paymentManagementService.attach(newUser);
 	serviceManagementService.attach(newUser);
 	if (newUser->getUserType() == util::UserType::ADMIN)
 	{
 		inventoryManagementService.attach(newUser);
 	}
+	m_dataStore.saveUsers();
 }

 /*
@@ -107,19 +115,25 @@ Return type: void
 */
 void UserManagementService::updateUserDetails(const std::string& userID, const std::string& email, const std::string& phone)
 {
-	auto& usersMap = m_dataStore.getUsers();
-	int index = usersMap.find(userID);
+    AuthenticationManagementService::ensureAuthorization();
+	DataStoreLockGuard lock(m_dataStore);
+	auto& trackedUsersMap = m_dataStore.getUsers();
+	auto usersMap = util::getObjects(trackedUsersMap);
+	int index = trackedUsersMap.find(userID);
 	if (index == -1)
 	{
 		throw std::runtime_error("User does not exist!\n");
 	}
-	User* user = usersMap.getValueAt(index);
+	User* user = trackedUsersMap.getValueAt(index).data;
+	bool isModified = false;
 	if (email != user->getEmail())
 	{
 		if (util::isEmailDuplicate(email, usersMap))
 		{
 			throw std::runtime_error("Email already exists!\n");
 		}
+		user->setEmail(email);
+		isModified = true;
 	}
 	if (phone != user->getPhone())
 	{
@@ -127,9 +141,14 @@ void UserManagementService::updateUserDetails(const std::string& userID, const s
 		{
 			throw std::runtime_error("Phone number already exists!\n");
 		}
+		user->setPhone(phone);
+		isModified = true;
+	}
+	if (isModified)
+	{
+		trackedUsersMap.getValueAt(index).state = RecordState::MODIFIED;
+		m_dataStore.saveUsers();
 	}
-	user->setEmail(email);
-	user->setPhone(phone);
 }

 /*
@@ -144,20 +163,26 @@ Throws:
 */
 util::Vector<Notification*> UserManagementService::getUserNotifications(const std::string& userID)
 {
-	auto& usersMap = m_dataStore.getUsers();
-	if (usersMap.find(userID) == -1)
+    AuthenticationManagementService::ensureAuthorization();
+	DataStoreLockGuard lock(m_dataStore);
+	auto& trackedUsersMap = m_dataStore.getUsers(); 
+	if (trackedUsersMap.find(userID) == -1)
 	{
 		throw std::runtime_error("No user found with given UserID");
 	}
-	User* user = usersMap[userID];
+	User* user = trackedUsersMap[userID].data;
 	if (user)
 	{
-		auto& notifications = user->getNotifications();
-		int numberOfNotifications = notifications.getSize();
+		auto& trackedNotificationMap = m_dataStore.getNotifications();
+		int numberOfNotifications = trackedNotificationMap.getSize();
 		util::Vector<Notification*> notificationsVector;
 		for (int index = 0; index < numberOfNotifications; index++)
 		{
-		    notificationsVector.push_back(notifications.getValueAt(index));
+			Notification* notification = trackedNotificationMap.getValueAt(index).data;
+			if (notification->getRecipientUserId() == userID && notification->getState() == util::State::ACTIVE)
+			{
+				notificationsVector.push_back(notification);
+			}
 		}
 		return notificationsVector;
 	}
@@ -169,97 +194,40 @@ util::Vector<Notification*> UserManagementService::getUserNotifications(const st

 /*
 Function: deleteNotification
-Description: Deletes a specific notification associated with a given user ID.
+Description: Marks a specific notification associated with a given user
+			 as inactive.
 Parameters:
 	- notificationID: The unique ID of the notification to be deleted.
 	- userID: The unique ID of the user whose notification is to be deleted.
 Returns:
 	- void
 Throws:
-	- std::runtime_error if no user is found with the given UserID or if no notification is found with the given NotificationID.
+	- std::runtime_error if no user is found with the given UserID or
+	  if no notification is found with the given NotificationID.
 */
 void UserManagementService::deleteNotification(const std::string& notificationID, const std::string& userID)
 {
-	auto& usersMap = m_dataStore.getUsers();
-	if (usersMap.find(userID) == -1)
+    AuthenticationManagementService::ensureAuthorization();
+	DataStoreLockGuard lock(m_dataStore);
+	auto& trackedUsersMap = m_dataStore.getUsers();
+	auto& trackedNotificationsMap = m_dataStore.getNotifications();
+	int userIndex = trackedUsersMap.find(userID);
+	if (userIndex == -1)
 	{
 		throw std::runtime_error("No user found with given UserID");
 	}
-	User* user = usersMap[userID];
-	auto& notifications = user->getNotifications();
-	if (notifications.find(notificationID) == -1)
+	int notificationIndex = trackedNotificationsMap.find(notificationID);
+	if (notificationIndex == -1)
 	{
 		throw std::runtime_error("No notification found with given NotificationID");
 	}
-	notifications.remove(notificationID);
-}
-
-/*
-Function: loadUsers
-Description: Loads users and notifications from persistent storage into the datastore.
-             Validates that each notification’s recipient exists and attaches the
-             notification to the corresponding user.
-Parameters:
-    - None
-Returns:
-    - void
-Throws:
-    - std::runtime_error if a notification recipient user ID is invalid
-*/
-void UserManagementService::loadUsers()
-{
-    util::FileManager<User> userFileManager(config::file::USER_FILE);
-    util::FileManager<Notification> notificationFileManager(config::file::NOTIFICATION_FILE);
-    auto& users = m_dataStore.getUsers();
-    auto usersMap = userFileManager.load();
-    auto notificationsMap = notificationFileManager.load();
-    int numberOfUsers = usersMap.getSize();
-    int numberOfNotifications = notificationsMap.getSize();
-    for (int index = 0; index < numberOfUsers; index++)
-    {
-        users[usersMap.getKeyAt(index)] = usersMap.getValueAt(index);
-    }
-    for (int index = 0; index < numberOfNotifications; index++)
-    {
-        Notification* notification = notificationsMap.getValueAt(index);
-        const std::string& recipientUserId = notification->getRecipientUserId();
-        int userIndex = users.find(recipientUserId);
-        if (userIndex == -1)
-        {
-            throw std::runtime_error("Invalid recipient user ID");
-        }
-        User* user = users.getValueAt(userIndex);
-        user->addNotification(notification);
-    }
-}
-
-/*
-Function: saveUsers
-Description: Saves users and their notifications from the datastore to persistent storage.
-             Collects notifications from all users into a single map before saving.
-Parameters:
-    - None
-Returns:
-    - void
-*/
-void UserManagementService::saveUsers()
-{
-    util::FileManager<User> userFileManager(config::file::USER_FILE);
-    util::FileManager<Notification> notificationFileManager(config::file::NOTIFICATION_FILE);
-    auto& users = m_dataStore.getUsers();
-    util::Map<std::string, Notification*> notifications;
-    for (int userIndex = 0; userIndex < users.getSize(); userIndex++)
-    {
-        User* user = users.getValueAt(userIndex);
-        auto& userNotifications = user->getNotifications();
-        for (int notificationIndex = 0; notificationIndex < userNotifications.getSize(); notificationIndex++)
-        {
-            notifications[userNotifications.getKeyAt(notificationIndex)] =
-                userNotifications.getValueAt(notificationIndex);
-        }
-    }
-    userFileManager.save(users);
-    notificationFileManager.save(notifications);
+	Notification* notification = trackedNotificationsMap.getValueAt(notificationIndex).data;
+	if (notification->getRecipientUserId() == userID)
+	{
+		notification->setState(util::State::INACTIVE);
+		trackedNotificationsMap.getValueAt(notificationIndex).state = RecordState::MODIFIED;
+		m_dataStore.saveNotifications();
+	}
 }

 /*
@@ -270,7 +238,9 @@ Return type: util::Map<std::string, User*>
 */
 util::Map<std::string, User*> UserManagementService::getUsers()
 {
-	return m_dataStore.getUsers();
+	DataStoreLockGuard lock(m_dataStore);
+	auto users = util::getObjects(m_dataStore.getUsers());
+	return users;
 }

 /*
@@ -281,10 +251,12 @@ Return type: User*
 */
 User* UserManagementService::getUser(const std::string& userID)
 {
-	int index = m_dataStore.getUsers().find(userID);
+	DataStoreLockGuard lock(m_dataStore);
+	auto& trackedUsersMap = m_dataStore.getUsers();
+	int index = trackedUsersMap.find(userID);
 	if (index != -1)
 	{
-		return m_dataStore.getUsers().getValueAt(index);
+		return trackedUsersMap.getValueAt(index).data;
 	}
 	return nullptr;
 }
@@ -297,38 +269,65 @@ Return type: void
 */
 void UserManagementService::removeUser(const std::string& userID)
 {
+    AuthenticationManagementService::ensureAuthorization();
 	InventoryManagementService inventoryManagementService;
 	PaymentManagementService paymentManagementService;
 	ServiceManagementService serviceManagementService;
-	int index = m_dataStore.getUsers().find(userID);
-	if (index != -1)
+	std::string removedUserID;
 	{
-		User* user = m_dataStore.getUsers().getValueAt(index);
-		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);
-			}
-			user->setState(util::State::INACTIVE);
-			inventoryManagementService.detach(user);
-			paymentManagementService.detach(user);
-			serviceManagementService.detach(user);
 		}
 	}
+	if (!removedUserID.empty())
+	{
+		EventManager::sendUserDisabledEvent(removedUserID);
+	}
 }

-util::Map<std::string, User*> UserManagementService::getUsers(util::UserType type)
+/*
+Function: getUsers
+Description: Retrieves all active users of the specified type from
+			 the DataStore.
+Parameters:
+	- type: The user type to filter by
+			(ADMIN, CUSTOMER, or TECHNICIAN).
+Returns:
+	- util::Map<std::string, User*>:
+	  Collection of active users matching the specified type,
+	  keyed by user ID.
+*/
+util::Map<std::string, User*> UserManagementService::getUsers(util::UserType type) 
 {
-	util::Map<std::string, User*>& currentUsers = m_dataStore.getUsers();
+	DataStoreLockGuard lock(m_dataStore);
+	auto& trackedUsersMap = m_dataStore.getUsers();
+	util::Map<std::string, User*> currentUsers = util::getObjects(trackedUsersMap);
 	util::Map<std::string, User*> filteredUsersMap;
-	for (int iterator = 0; iterator < currentUsers.getSize(); iterator++)
+	for (int index = 0; index < currentUsers.getSize(); index++)
 	{
-		User* currentUser = currentUsers.getValueAt(iterator);
+		User* currentUser = currentUsers.getValueAt(index);
 		if (currentUser && currentUser->getState() == util::State::ACTIVE && currentUser->getUserType() == type)
 		{
 			filteredUsersMap.insert(currentUser->getId(), currentUser);
@@ -31,6 +31,4 @@ public:
    util::Vector<Notification*> getUserNotifications(const std::string& userID);
    void deleteNotification(const std::string& notificationID, const std::string& userID);
    void ensureAdminExists();
-    void loadUsers();
-    void saveUsers();
 };
@@ -29,6 +29,7 @@ namespace config
 	namespace file
 	{
 		const size_t INITIAL_CAPACITY = 100;
+		const size_t GROWTH_FACTOR = 2;
 		constexpr const char* DIRECTORY = "files/";
 		constexpr const char* INVENTORYITEM_FILE = "files/InventoryItem.dat";
 		constexpr const char* USER_FILE = "files/User.dat";
@@ -43,67 +43,4 @@ namespace util
            position++;
        }
    }
-
-    /*
-    Function: loadRecords
-    Description: Loads records from a given file path into a vector of strings.
-                 Skips the header line if present. Creates the file if it does not exist.
-    Parameters:
-        - filePath: const std::string&, path to the file
-    Returns:
-        - util::Vector<std::string>: Vector containing all records (excluding header)
-    Throws:
-        - None (creates file if missing)
-    */
-    inline util::Vector<std::string> loadRecords(const std::string& filePath)
-    {
-        util::Vector<std::string> records;
-        std::ifstream file(filePath);
-        if (!file.is_open())
-        {
-            ensureDirectoryExists(filePath);
-            std::ofstream newFile(filePath);
-            newFile.close();
-            file.open(filePath);
-        }
-        std::string line;
-        bool isHeader = true;
-        while (std::getline(file, line))
-        {
-            if (isHeader)
-            {
-                isHeader = false;
-                continue;
-            }
-            records.push_back(line);
-        }
-        return records;
-    }
-
-    /*
-    Function: saveRecords
-    Description: Saves records to a given file path. Overwrites existing content
-                 and writes a header line followed by all records.
-    Parameters:
-        - filePath: const std::string&, path to the file
-        - records: const util::Vector<std::string>&, vector of records to save
-    Returns:
-        - void
-    Throws:
-        - std::runtime_error if the file cannot be opened for writing
-    */
-    inline void saveRecords(const std::string& filePath, const util::Vector<std::string>& records)
-    {
-        std::ofstream file(filePath, std::ios::trunc);
-        if (!file.is_open())
-        {
-            throw std::runtime_error("Failed to open file " + filePath);
-        }
-        file << "Values" << '\n';
-        int numberOfRecords = records.getSize();
-        for (int index = 0; index < numberOfRecords; index++)
-        {
-            file << records[index] << '\n';
-        }
-    }
 }
@@ -1,119 +0,0 @@
-/*
-File: FileManager.h
-Description: Declares and implements a generic FileManager template class for
-			 loading and saving objects to and from files. Uses serialization
-			 and deserialization methods defined in the object type T.
-			 Provides persistence support for system entities such as Users,
-			 Services, InventoryItems, etc.
-Author: Trenser
-Date: 22-May-2026
-*/
-
-#pragma once
-#include <stdexcept>
-#include <string>
-#include <fstream>
-#include "Vector.h"
-#include "Map.h"
-#include "FileHelper.h"
-
-namespace util
-{
-	template <typename T> using objects = util::Map<std::string, T*>;
-
-	template <typename T>
-	class FileManager
-	{
-	private:
-		std::string m_filePath;
-	public:
-		FileManager() : m_filePath("") {}
-		FileManager(const std::string& filePath) : m_filePath(filePath) {}
-		objects<T> load();
-		void save(const objects<T>&);
-	};
-
-	/*
-	Function: load
-	Description: Loads records from the file into a map of objects.
-				 Skips the header line, deserializes each record into an object of type T,
-				 and stores them in a map keyed by object ID.
-	Parameters:
-		- None
-	Returns:
-		- util::Map<std::string, T*> containing deserialized objects
-	Throws:
-		- std::runtime_error if deserialization fails for any record
-	*/
-	template <typename T>
-	objects<T> FileManager<T>::load()
-	{
-		objects<T> records;
-		std::ifstream file(m_filePath);
-		if (!file.is_open())
-		{
-			ensureDirectoryExists(m_filePath);
-			std::ofstream newFile(m_filePath);
-			newFile.close();
-			file.open(m_filePath);
-		}
-		util::Vector<std::string> lines;
-		std::string line;
-		while (std::getline(file, line))
-		{
-			lines.push_back(line);
-		}
-		int numberOfLines = lines.getSize();
-		bool isHeader = true;
-		for (int lineIndex = 0; lineIndex < numberOfLines; lineIndex++)
-		{
-			const auto& record = lines[lineIndex];
-			if (isHeader)
-			{
-				isHeader = false;
-				continue;
-			}
-			auto object = T::deserialize(record);
-			if (!object)
-			{
-				throw std::runtime_error("Failed to deserialize record");
-			}
-			records[object->getId()] = object;
-		}
-		return records;
-	}
-
-	/*
-	Function: save
-	Description: Saves records to the file. Serializes each object of type T into a string,
-				 writes a header line, and then writes all serialized records to the file.
-	Parameters:
-		- records: const util::Map<std::string, T*>&, map of objects to save
-	Returns:
-		- void
-	Throws:
-		- std::runtime_error if the file cannot be opened for writing
-	*/
-	template <typename T>
-	void FileManager<T>::save(const objects<T>& records)
-	{
-		util::Vector<std::string> lines;
-		lines.push_back(T::getHeaders());
-		int numberOfRecords = records.getSize();
-		for (int recordIndex = 0; recordIndex < numberOfRecords; recordIndex++)
-		{
-			const auto& record = records.getValueAt(recordIndex);
-			lines.push_back(record->serialize());
-		}
-		std::ofstream file(m_filePath, std::ios::trunc);
-		if (!file.is_open())
-		{
-			throw std::runtime_error("Failed to open file " + m_filePath);
-		}
-		int numberOfLines = lines.getSize();
-		for (int lineIndex = 0; lineIndex < numberOfLines; lineIndex++)
-		{
-			file << lines[lineIndex] << '\n';
-		}
-	}
-}
@@ -28,7 +28,7 @@ namespace util
        if (!(std::cin >> value))
        {
            std::cin.clear();
-            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+            std::cin.ignore((std::numeric_limits<std::streamsize>::max)(), '\n');
            throw std::runtime_error("Invalid console input");
        }
    }
@@ -54,52 +54,6 @@ namespace util
        return cost;
    }

-    /*
-    Function: loadObservers
-    Description: Loads observer IDs from a file and attaches the corresponding users
-                 to the notification management service. Validates that each observer ID
-                 exists in the datastore before attaching.
-    Parameters:
-        - filePath: const std::string&, path to the file containing observer IDs
-        - service: NotificationManagementService*, pointer to the notification service
-        - dataStore: DataStore&, reference to the datastore containing users
-    Returns:
-        - void
-    Throws:
-        - std::runtime_error if an observer ID is invalid (not found in datastore)
-    */
-    inline void loadObservers(const std::string& filePath, NotificationManagementService* service, DataStore& dataStore)
-    {
-        auto observerIDs = util::loadRecords(filePath);
-        auto& users = dataStore.getUsers();
-        for (int index = 0; index < observerIDs.getSize(); index++)
-        {
-            const std::string& observerID = observerIDs[index];
-            int userIndex = users.find(observerID);
-            if (userIndex == -1)
-            {
-                throw std::runtime_error("Invalid Observer ID");
-            }
-            service->attach(users.getValueAt(userIndex));
-        }
-    }
-
-    /*
-    Function: saveObservers
-    Description: Saves the current observer IDs from the notification management service
-                 to a file for persistence.
-    Parameters:
-        - filePath: const std::string&, path to the file where observer IDs will be saved
-        - service: NotificationManagementService*, pointer to the notification service
-    Returns:
-        - void
-    */
-    inline void saveObservers(const std::string& filePath, NotificationManagementService* service)
-    {
-        auto observerIDs = service->getObserverIDs();
-        util::saveRecords(filePath, observerIDs);
-    }
-
    template<typename TObject>
    Map<std::string, TObject*> getObjects(const Map<std::string, TrackedRecord<TObject>>& trackedRecords);

@@ -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,25 @@ 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();
+	const User* authenticatedUser = m_controller.getAuthenticatedUser();
+	std::string name;
+	if (authenticatedUser)
+	{
+		name = authenticatedUser->getName();
+	}
+	displayNewNotification(notifications, name);
+}
+
 /*
 Function: logout
 Description: Logs out the currently authenticated admin user.
@@ -307,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();
@@ -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();
@@ -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"
@@ -44,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))
@@ -62,6 +70,7 @@ void CustomerMenu::showMenu()
            util::pressEnter();
        }
    }
+    stopEventListener();
 }

 /*
@@ -72,6 +81,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:
@@ -90,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:
@@ -111,6 +128,25 @@ 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();
+    const User* authenticatedUser = m_controller.getAuthenticatedUser();
+    std::string name;
+    if (authenticatedUser)
+    {
+        name = authenticatedUser->getName();
+    }
+    displayNewNotification(notifications, name);
+}
+
 /*
 Function: logout
 Description: Logs out the currently authenticated customer user.
@@ -184,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)
@@ -226,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)
    {
@@ -301,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.
@@ -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();
@@ -27,5 +28,6 @@ public:
    void completePayments();
    void viewInvoices();
    void viewNotifications();
+    void cancelServiceBooking();
    void configureNotifications();
-};
+};
@@ -0,0 +1,150 @@
+/*
+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] = { NULL, NULL, NULL };
+    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);
+    const User* authenticatedUser = m_controller.getAuthenticatedUser();
+    std::string messageTitle = "Account Disabled";
+    if (authenticatedUser)
+    {
+        messageTitle += " - " + authenticatedUser->getName();
+    }
+    MessageBoxA(
+        GetConsoleWindow(),
+        "Your account has been disabled.",
+        messageTitle.c_str(),
+        MB_OK |
+        MB_ICONWARNING |
+        MB_SETFOREGROUND |
+        MB_TOPMOST);
+}
@@ -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();
+};
@@ -28,6 +28,7 @@ Date: 21-May-2026
 #include "Utility.h"
 #include "Validator.h"
 #include "Vector.h"
+#include "StringHelper.h"

 /*
 Function: displayAllServices
@@ -587,7 +588,7 @@ inline void displayInvoices(util::Map<std::string, const Invoice*> currentUserIn
                    << util::getPaymentStatusString(selectedInvoice->getStatus()) << std::endl;
                std::cout << std::left << std::setw(20) << "Payment Mode:"
                    << util::getPaymentModeString(selectedInvoice->getPaymentMethod()) << std::endl;
-                auto inventoryItemsInInvoice = selectedInvoice->getParts();
+                auto& inventoryItemsInInvoice = selectedInvoice->getParts();
                if (inventoryItemsInInvoice.isEmpty())
                {
                    std::cout << "No inventory items used.\n\n";
@@ -596,7 +597,6 @@ inline void displayInvoices(util::Map<std::string, const Invoice*> currentUserIn
                std::cout << "\nItems Used:\n";
                std::cout << std::left
                    << std::setw(20) << "ItemName"
-                    << std::setw(10) << "Quantity"
                    << std::setw(10) << "Price"
                    << std::endl;
                std::cout << std::string(40, '-') << std::endl;
@@ -605,7 +605,6 @@ inline void displayInvoices(util::Map<std::string, const Invoice*> currentUserIn
                    InventoryItem* currentItem = inventoryItemsInInvoice.getValueAt(iterator);
                    std::cout << std::left
                        << std::setw(20) << currentItem->getPartName()
-                        << std::setw(10) << currentItem->getQuantity()
                        << std::setw(10) << currentItem->getPrice()
                        << std::endl;
                }
@@ -1056,6 +1055,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
@@ -1130,15 +1144,18 @@ inline void displayAllComboPackages(util::Map<std::string, const ComboPackage*>
    for (int index = 0; index < comboPackages.getSize(); index++)
    {
        const ComboPackage* currentComboPackage = comboPackages.getValueAt(index);
-        if (currentComboPackage && currentComboPackage->getState() != util::State::ACTIVE)
+        if (currentComboPackage) 
        {
-            continue;
+            if (currentComboPackage->getState() != util::State::ACTIVE)
+            {
+                continue;
+            }
+            std::cout << std::left
+                << std::setw(15) << currentComboPackage->getId()
+                << std::setw(35) << util::truncateString(currentComboPackage->getPackageName(), 30)
+                << std::setw(15) << util::calculateComboServiceEstimatedCost(currentComboPackage)
+                << std::endl;
        }
-        std::cout << std::left
-            << std::setw(15) << currentComboPackage->getId()
-            << std::setw(35) << util::truncateString(currentComboPackage->getPackageName(), 30)
-            << std::setw(15) << util::calculateComboServiceEstimatedCost(currentComboPackage)
-            << std::endl;
    }
 }

@@ -1164,18 +1181,21 @@ inline const ComboPackage* selectComboPackageFromPackages(const util::Map<std::s
    for (int index = 0; index < comboPackages.getSize(); index++)
    {
        const ComboPackage* currentComboPackage = comboPackages.getValueAt(index);
-        if (currentComboPackage && currentComboPackage->getState() != util::State::ACTIVE)
+        if (currentComboPackage)
        {
-            continue;
+            if (currentComboPackage->getState() != util::State::ACTIVE)
+            {
+                continue;
+            }
+            activeComboPackages.insert(currentIndex, currentComboPackage);
+            std::cout << std::left
+                << std::setw(10) << currentIndex
+                << std::setw(15) << currentComboPackage->getId()
+                << std::setw(35) << util::truncateString(currentComboPackage->getPackageName(), 30)
+                << std::setw(15) << util::calculateComboServiceEstimatedCost(currentComboPackage)
+                << std::endl;
+            currentIndex++;
        }
-        activeComboPackages.insert(currentIndex, currentComboPackage);
-        std::cout << std::left
-            << std::setw(10) << currentIndex
-            << std::setw(15) << currentComboPackage->getId()
-            << std::setw(35) << util::truncateString(currentComboPackage->getPackageName(), 30)
-            << std::setw(15) << util::calculateComboServiceEstimatedCost(currentComboPackage)
-            << std::endl;
-        currentIndex++;
    }
    if (activeComboPackages.getSize() == 0)
    {
@@ -1407,4 +1427,89 @@ inline std::string selectComboPackage(util::Map<std::string, const ComboPackage*
        std::cout << "Enter a valid choice.\n";
        return "";
    }
-}
+}
+
+/*
+Function: displayNewNotification
+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, const std::string& name)
+{
+    const Notification* notification = nullptr;
+	size_t numberOfNotifications = notifications.getSize();
+	for (int index = 0; index < numberOfNotifications; index++)
+	{
+		if (!notification)
+		{
+			notification = notifications[index];
+		}
+		else
+		{
+            if (util::extractNumber(notification->getId()) < util::extractNumber(notifications[index]->getId()))
+			{
+				notification = notifications[index];
+			}
+		}
+	}
+    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;
+}
@@ -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,25 @@ 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();
+    const User* authenticatedUser = m_controller.getAuthenticatedUser();
+    std::string name;
+    if (authenticatedUser)
+    {
+        name = authenticatedUser->getName();
+    }
+    displayNewNotification(notifications, name);
+}
+
 /*
 Function: displayJobs
 Description: Displays all Jobs assigned to a Technician
@@ -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();
@@ -27,8 +27,11 @@ void UserInterface::run()
 {
 	try
 	{
-		m_controller.loadSystemData();
-		m_controller.runSystemChecks();
+		if (!m_controller.initialize())
+		{
+			std::cout << "Error: Failed to initialize the system!";
+			return;
+		}
 		bool isMenuActive = true;
 		while (isMenuActive)
 		{
@@ -49,7 +52,7 @@ void UserInterface::run()
 				util::pressEnter();
 			}
 		}
-		m_controller.saveSystemData();
+		m_controller.shutdown();
 	}
 	catch (const std::invalid_argument& exception)
 	{