Fix cache refresh handling for unsaved records

- Preserve NEW_RECORD entries during cache refresh - Prevent accidental deletion of pending datastore changes - Clean up only stale persisted records
Clean up legacy code
2026-06-14 17:00:49 +05:30 · 2026-06-14 15:59:39 +05:30 · 2026-06-12 19:25:27 +05:30 · 2026-06-12 17:36:15 +05:30
44 changed files with 648 additions and 1730 deletions
@@ -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)core\sharedmemory;$(ProjectDir)core\events;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)factories;$(ProjectDir)views;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)core\patterns;$(ProjectDir)datastores;$(ProjectDir)datastores\sharedmemory;%(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)core\sharedmemory;$(ProjectDir)core\events;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)factories;$(ProjectDir)views;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)core\patterns;$(ProjectDir)datastores;$(ProjectDir)datastores\sharedmemory;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
@@ -126,11 +126,10 @@
  </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" />
@@ -149,23 +148,21 @@
    <ClCompile Include="utilities\Validator.cpp" />
    <ClCompile Include="views\AdminMenu.cpp" />
    <ClCompile Include="views\CustomerMenu.cpp" />
-    <ClCompile Include="views\Menu.cpp" />
    <ClCompile Include="views\TechnicianMenu.cpp" />
    <ClCompile Include="views\UserInterface.cpp" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="controllers\Controller.h" />
-    <ClInclude Include="core\events\EventManager.h" />
    <ClInclude Include="core\patterns\Observer.h" />
    <ClInclude Include="core\patterns\Subject.h" />
-    <ClInclude Include="core\sharedmemory\FileHeader.h" />
-    <ClInclude Include="core\sharedmemory\MappingInfo.h" />
-    <ClInclude Include="core\sharedmemory\RecordState.h" />
-    <ClInclude Include="core\sharedmemory\SerializedRecords.h" />
-    <ClInclude Include="core\sharedmemory\SharedMemory.h" />
-    <ClInclude Include="core\sharedmemory\TrackedRecord.h" />
    <ClInclude Include="datastores\DataStore.h" />
    <ClInclude Include="datastores\DataStoreLockGuard.h" />
+    <ClInclude Include="datastores\sharedmemory\FileHeader.h" />
+    <ClInclude Include="datastores\sharedmemory\MappingInfo.h" />
+    <ClInclude Include="datastores\sharedmemory\RecordState.h" />
+    <ClInclude Include="datastores\sharedmemory\SerializedRecords.h" />
+    <ClInclude Include="datastores\sharedmemory\SharedMemory.h" />
+    <ClInclude Include="datastores\sharedmemory\TrackedRecord.h" />
    <ClInclude Include="factories\Factory.h" />
    <ClInclude Include="models\ComboPackage.h" />
    <ClInclude Include="models\InventoryItem.h" />
@@ -194,7 +191,6 @@
    <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,17 +64,11 @@
    <Filter Include="Source Files\Core\Patterns">
      <UniqueIdentifier>{8057b93d-51a9-42df-b06e-01ce395f6308}</UniqueIdentifier>
    </Filter>
-    <Filter Include="Header Files\Core\SharedMemory">
-      <UniqueIdentifier>{d9da9793-fe6f-4914-bee3-99d5934da228}</UniqueIdentifier>
+    <Filter Include="Header Files\DataStores\SharedMemory">
+      <UniqueIdentifier>{ec639004-44c6-4bd6-9963-077adde82b5f}</UniqueIdentifier>
    </Filter>
-    <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 Include="Source Files\DataStores\SharedMemory">
+      <UniqueIdentifier>{7aa8722e-adfa-466e-8211-de63f3b7892b}</UniqueIdentifier>
    </Filter>
  </ItemGroup>
  <ItemGroup>
@@ -150,14 +144,8 @@
    <ClCompile Include="models\ComboPackage.cpp">
      <Filter>Source Files\Models</Filter>
    </ClCompile>
-    <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 Include="datastores\sharedmemory\SharedMemory.cpp">
+      <Filter>Source Files\DataStores\SharedMemory</Filter>
    </ClCompile>
  </ItemGroup>
  <ItemGroup>
@@ -266,32 +254,26 @@
    <ClInclude Include="views\MenuHelper.h">
      <Filter>Header Files\Views</Filter>
    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\FileHeader.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\MappingInfo.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\RecordState.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\TrackedRecord.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\SerializedRecords.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\SharedMemory.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
    <ClInclude Include="datastores\DataStoreLockGuard.h">
      <Filter>Header Files\DataStores</Filter>
    </ClInclude>
-    <ClInclude Include="core\sharedmemory\FileHeader.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="core\sharedmemory\MappingInfo.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="core\sharedmemory\RecordState.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="core\sharedmemory\SerializedRecords.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="core\sharedmemory\SharedMemory.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="core\sharedmemory\TrackedRecord.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="core\events\EventManager.h">
-      <Filter>Header Files\Core\Events</Filter>
-    </ClInclude>
-    <ClInclude Include="views\Menu.h">
-      <Filter>Header Files\Views</Filter>
-    </ClInclude>
  </ItemGroup>
 </Project>
@@ -234,17 +234,6 @@ 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.
@@ -276,7 +265,6 @@ util::Map<std::string, const ServiceBooking*> Controller::getServiceBookings()
    return readOnlyServiceBookings;
 }

-
 /*
 Function: getServiceBookingsByUser
 Description: Retrieves all service bookings for a specific user.
@@ -634,16 +622,3 @@ 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,7 +8,6 @@ Date:19-May-2026
 */

 #pragma once
-#include <windows.h>
 #include <string>
 #include "AuthenticationManagementService.h"
 #include "Enums.h"
@@ -58,7 +57,6 @@ 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);
@@ -74,5 +72,4 @@ public:
    void configureNotifications(bool paymentNotifications, bool serviceNotifications);
    bool initialize();
    void shutdown();
-    void registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent);
 };
@@ -1,225 +0,0 @@
-/*
-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);
-}
@@ -1,37 +0,0 @@
-/*
-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);
-};
@@ -12,9 +12,6 @@ Date: 19-May-2026
 #include "Config.h"
 #include "SerializedRecords.h"
 #include "FileHelper.h"
-#include "ServiceBooking.h"
-#include "JobCard.h"
-#include "Invoice.h"

 /*
 Function: DataStore
@@ -255,28 +252,6 @@ 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;
 }

@@ -290,28 +265,6 @@ 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;
 }

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

@@ -340,49 +291,6 @@ 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;
 }

@@ -396,51 +304,9 @@ 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.
@@ -451,45 +317,6 @@ 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;
 }

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

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

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

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

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

 /*
@@ -664,7 +486,6 @@ Returns:
 */
 void DataStore::saveInvoices()
 {
-    saveRecords<Invoice, SerializedInvoice>(m_invoices, m_invoiceCache);
 }

 /*
@@ -781,3 +602,4 @@ bool DataStore::unlockDataStore()
    }
    return ReleaseMutex(m_globalMutex) != 0;
 }
+
@@ -11,7 +11,6 @@ Date: 19-May-2026
 #include "Map.h"
 #include "MappingInfo.h"
 #include "TrackedRecord.h"
-#include "SerializedRecords.h"
 #include "SharedMemory.h"
 #include "User.h"
 #include "Notification.h"
@@ -220,12 +219,6 @@ 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;
@@ -9,7 +9,6 @@ Date: 19-May-2026

 #include <sstream>
 #include <stdexcept>
-#include "SerializedRecords.h"
 #include "ComboPackage.h"
 #include "Service.h"
 #include "Factory.h"
@@ -29,8 +28,7 @@ Returns:
 ComboPackage::ComboPackage()
    : m_id("CMP" + std::to_string(++m_uid)),
    m_status(util::State::ACTIVE),
-    m_discountPercentage(0.0) {
-}
+    m_discountPercentage(0.0) {}

 /*
 Function: ComboPackage
@@ -272,38 +270,72 @@ static util::Vector<std::string> getServiceIDsAsVector(const std::string& servic

 /*
 Function: serialize
-Description: Serializes the ComboPackage object into a SerializedComboPackage record.
+Description: Serializes the combo package into a CSV-formatted string.
 Parameters:
    - None
 Returns:
-    - SerializedComboPackage: Serialized representation of the combo package
+    - std::string: Serialized combo package record
 */
-SerializedComboPackage ComboPackage::serialize() const
+std::string ComboPackage::serialize() const
 {
-    SerializedComboPackage serialized = {};
-    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
-    strcpy_s(serialized.packageName, sizeof(serialized.packageName), m_packageName.c_str());
-    strcpy_s(serialized.serviceIDs, sizeof(serialized.serviceIDs), getServiceIDsAsString(m_serviceIDs).c_str());
-    serialized.discountPercentage = m_discountPercentage;
-    serialized.status = m_status;
-    return serialized;
+    std::ostringstream serializedComboPackage;
+    serializedComboPackage << m_id << ','
+        << m_packageName << ','
+        << m_discountPercentage << ','
+        << getServiceIDsAsString(m_serviceIDs) << ','
+        << util::getStateString(m_status);
+    return serializedComboPackage.str();
 }

 /*
 Function: deserialize
-Description: Deserializes a SerializedComboPackage record into a ComboPackage object.
+Description: Deserializes a CSV-formatted string into a ComboPackage object.
 Parameters:
-    - serializedComboPackage: const SerializedComboPackage&, serialized combo package record
+    - record: const std::string&, serialized combo package record
 Returns:
    - ComboPackage*: Pointer to the deserialized ComboPackage object
+Throws:
+    - std::runtime_error if data is invalid
 */
-ComboPackage* ComboPackage::deserialize(const SerializedComboPackage& serializedComboPackage)
+ComboPackage* ComboPackage::deserialize(const std::string& record)
 {
-    util::Vector<std::string> serviceIDs = getServiceIDsAsVector(serializedComboPackage.serviceIDs);
+    std::string id, packageName;
+    std::string discountPercentageString, serviceIDsString, statusString;
+    double discountPercentage;
+    std::istringstream serializedComboPackage(record);
+    getline(serializedComboPackage, id, ',');
+    getline(serializedComboPackage, packageName, ',');
+    getline(serializedComboPackage, discountPercentageString, ',');
+    getline(serializedComboPackage, serviceIDsString, ',');
+    getline(serializedComboPackage, statusString, ',');
+    try
+    {
+        discountPercentage = std::stod(discountPercentageString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid combo package data");
+    }
+    util::Vector<std::string> serviceIDs = getServiceIDsAsVector(serviceIDsString);
+    util::State status = util::getState(statusString);
    return Factory::getObject<ComboPackage>(
-        serializedComboPackage.id,
-        serializedComboPackage.packageName,
-        serializedComboPackage.discountPercentage,
+        id,
+        packageName,
+        discountPercentage,
        serviceIDs,
-        serializedComboPackage.status);
+        status
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for combo package serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,PackageName,DiscountPercentage,ServiceIDs,Status")
+*/
+std::string ComboPackage::getHeaders()
+{
+    return "ID,PackageName,DiscountPercentage,ServiceIDs,Status";
 }
@@ -39,6 +39,7 @@ public:
    void setDiscountPercentage(double discountPercentage);
    void setServices(const util::Map<std::string, Service*>& services);
    void setState(util::State status);
-    SerializedComboPackage serialize() const;
-    static ComboPackage* deserialize(const SerializedComboPackage&);
+    std::string serialize() const;
+    static ComboPackage* deserialize(const std::string&);
+    static std::string getHeaders();
 };
@@ -8,7 +8,6 @@ Date: 19-May-2026

 #include <sstream>
 #include <stdexcept>
-#include "SerializedRecords.h"
 #include "Factory.h"
 #include "StringHelper.h"
 #include "InventoryItem.h"
@@ -28,8 +27,7 @@ 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
@@ -47,8 +45,7 @@ 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)
@@ -209,37 +206,73 @@ void InventoryItem::setState(util::State status)

 /*
 Function: serialize
-Description: Serializes the InventoryItem object into a SerializedInventoryItem record.
+Description: Serializes the inventory item into a CSV-formatted string.
 Parameters:
    - None
 Returns:
-    - SerializedInventoryItem: Serialized representation of the inventory item
+    - std::string: Serialized inventory item record
 */
-SerializedInventoryItem InventoryItem::serialize() const
+std::string InventoryItem::serialize() const
 {
-    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;
+    std::ostringstream serializedInventoryItem;
+    serializedInventoryItem << m_id << ','
+        << m_partName << ','
+        << m_quantity << ','
+        << m_price << ','
+        << util::getStateString(m_status);
+    return serializedInventoryItem.str();
 }

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

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

-struct SerializedInventoryItem;
-
 class InventoryItem
 {
 private:
@@ -35,6 +34,7 @@ public:
    void setQuantity(int quantity);
    void setPrice(double price);
    void setState(util::State status);
-    SerializedInventoryItem serialize() const;
-    static InventoryItem* deserialize(const SerializedInventoryItem&);
+    std::string serialize() const;
+    static InventoryItem* deserialize(const std::string&);
+    static std::string getHeaders();
 };
@@ -9,7 +9,6 @@ Date: 19-May-2026

 #include <sstream>
 #include <stdexcept>
-#include "SerializedRecords.h"
 #include "Invoice.h"
 #include "Factory.h"
 #include "InventoryItem.h"
@@ -35,8 +34,7 @@ Invoice::Invoice()
    m_discountPercentage(0.0),
    m_totalAmount(0.0),
    m_paymentMethod(util::PaymentMode()),
-    m_status(util::PaymentStatus()) {
-}
+    m_status(util::PaymentStatus()) {}

 /*
 Function: Invoice
@@ -68,7 +66,7 @@ Invoice::Invoice(
    const util::Timestamp& paymentDate, 
    util::PaymentMode paymentMethod, 
    util::PaymentStatus status
-)
+    )
    : m_id("INV" + std::to_string(++m_uid)),
    m_bookingId(bookingId),
    m_booking(booking),
@@ -475,50 +473,100 @@ static util::Vector<std::string> getPartIDsAsVector(const std::string& partIDsSt

 /*
 Function: serialize
-Description: Serializes the Invoice object into a SerializedInvoice record.
+Description: Serializes the invoice into a CSV-formatted string.
 Parameters:
    - None
 Returns:
-    - SerializedInvoice: Serialized representation of the invoice
+    - std::string: Serialized invoice record
 */
-SerializedInvoice Invoice::serialize() const
+std::string Invoice::serialize() const
 {
-    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;
+    std::ostringstream serializedInvoice;
+    serializedInvoice << m_id << ','
+        << m_bookingId << ','
+        << m_invoiceDate.toString() << ','
+        << m_laborCost << ','
+        << getPartIDsAsString(m_partIDs) << ','
+        << m_partsCost << ','
+        << m_discountPercentage << ','
+        << m_totalAmount << ','
+        << m_paymentDate.toString() << ','
+        << util::getPaymentModeString(m_paymentMethod) << ','
+        << util::getPaymentStatusString(m_status);
+    return serializedInvoice.str();
 }

 /*
 Function: deserialize
-Description: Deserializes a SerializedInvoice record into an Invoice object.
+Description: Deserializes a CSV-formatted string into an Invoice object.
 Parameters:
-    - serializedInvoice: const SerializedInvoice&, serialized invoice record
+    - record: const std::string&, serialized invoice record
 Returns:
    - Invoice*: Pointer to the deserialized Invoice object
+Throws:
+    - std::runtime_error if data is invalid
 */
-Invoice* Invoice::deserialize(const SerializedInvoice& serializedInvoice)
+Invoice* Invoice::deserialize(const std::string& record)
 {
-    util::Vector<std::string> partIDs = getPartIDsAsVector(serializedInvoice.partIDs);
+    std::string id, bookingId;
+    std::string invoiceDateString, laborCostString, partIDsString;
+    std::string partsCostString, discountPercentageString, totalAmountString;
+    std::string paymentDateString, paymentMethodString, statusString;
+    double laborCost, partsCost, discountPercentage, totalAmount;
+    std::istringstream serializedInvoice(record);
+    getline(serializedInvoice, id, ',');
+    getline(serializedInvoice, bookingId, ',');
+    getline(serializedInvoice, invoiceDateString, ',');
+    getline(serializedInvoice, laborCostString, ',');
+    getline(serializedInvoice, partIDsString, ',');
+    getline(serializedInvoice, partsCostString, ',');
+    getline(serializedInvoice, discountPercentageString, ',');
+    getline(serializedInvoice, totalAmountString, ',');
+    getline(serializedInvoice, paymentDateString, ',');
+    getline(serializedInvoice, paymentMethodString, ',');
+    getline(serializedInvoice, statusString, ',');
+    util::Timestamp invoiceDate;
+    util::Timestamp paymentDate;
+    try
+    {
+        invoiceDate = util::Timestamp::fromString(invoiceDateString);
+        paymentDate = util::Timestamp::fromString(paymentDateString);
+        laborCost = std::stod(laborCostString);
+        partsCost = std::stod(partsCostString);
+        discountPercentage = std::stod(discountPercentageString);
+        totalAmount = std::stod(totalAmountString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid invoice data");
+    }
+    util::Vector<std::string> partIDs = getPartIDsAsVector(partIDsString);
+    util::PaymentMode paymentMethod = util::getPaymentMode(paymentMethodString);
+    util::PaymentStatus status = util::getPaymentStatus(statusString);
    return Factory::getObject<Invoice>(
-        serializedInvoice.id,
-        serializedInvoice.bookingId,
-        serializedInvoice.invoiceDate,
+        id,
+        bookingId,
+        invoiceDate,
        partIDs,
-        serializedInvoice.laborCost,
-        serializedInvoice.partsCost,
-        serializedInvoice.discountPercentage,
-        serializedInvoice.totalAmount,
-        serializedInvoice.paymentDate,
-        serializedInvoice.paymentMethod,
-        serializedInvoice.status);
+        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";
 }
@@ -6,6 +6,7 @@ Author: Trenser
 Date: 19-May-2026
 */

+
 #pragma once
 #include <string>
 #include "Map.h"
@@ -15,7 +16,6 @@ Date: 19-May-2026

 class ServiceBooking;
 class InventoryItem;
-struct SerializedInvoice;

 class Invoice
 {
@@ -41,7 +41,7 @@ public:
        ServiceBooking* booking,
        const util::Timestamp& invoiceDate, 
        double laborCost, 
-        const util::Map<std::string, InventoryItem*>& parts,
+        const util::Map<std::string,InventoryItem*>& parts,
        double partsCost,
        double discountPercentage, 
        double totalAmount, 
@@ -87,6 +87,7 @@ public:
    void setPaymentDate(const util::Timestamp& paymentDate);
    void setPaymentMethod(util::PaymentMode paymentMethod);
    void setStatus(util::PaymentStatus status);
-    SerializedInvoice serialize() const;
-    static Invoice* deserialize(const SerializedInvoice&);
+    std::string serialize() const;
+    static Invoice* deserialize(const std::string&);
+    static std::string getHeaders();
 };
@@ -9,7 +9,6 @@ Date:19-May-2026

 #include <sstream>
 #include <stdexcept>
-#include "SerializedRecords.h"
 #include "JobCard.h"
 #include "Factory.h"
 #include "StringHelper.h"
@@ -29,8 +28,7 @@ JobCard::JobCard()
    m_booking(nullptr),
    m_service(nullptr),
    m_technician(nullptr),
-    m_status(util::ServiceJobStatus()) {
-}
+    m_status(util::ServiceJobStatus()) {}

 /*
 Function: JobCard
@@ -67,8 +65,7 @@ JobCard::JobCard(const std::string& bookingId,
    m_technician(technician),
    m_assignedDate(assignedDate),
    m_status(status),
-    m_completionDate(completionDate) {
-}
+    m_completionDate(completionDate) {}

 /*
 Function: JobCard (parameterized constructor with ID)
@@ -354,41 +351,79 @@ void JobCard::setCompletionDate(const util::Timestamp& completionDate)

 /*
 Function: serialize
-Description: Serializes the JobCard object into a SerializedJobCard record.
+Description: Serializes the job card into a CSV-formatted string.
 Parameters:
    - None
 Returns:
-    - SerializedJobCard: Serialized representation of the job card
+    - std::string: Serialized job card record
 */
-SerializedJobCard JobCard::serialize() const
+std::string JobCard::serialize() const
 {
-    SerializedJobCard 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.serviceId, sizeof(serialized.serviceId), m_serviceId.c_str());
-    strcpy_s(serialized.technicianId, sizeof(serialized.technicianId), m_technicianId.c_str());
-    serialized.assignedDate = m_assignedDate;
-    serialized.status = m_status;
-    serialized.completionDate = m_completionDate;
-    return serialized;
+    std::ostringstream serializedJobCard;
+    serializedJobCard << m_id << ','
+        << m_bookingId << ','
+        << m_serviceId << ','
+        << m_technicianId << ','
+        << m_assignedDate.toString() << ','
+        << util::getServiceJobStatusString(m_status) << ','
+        << m_completionDate.toString();
+    return serializedJobCard.str();
 }

 /*
 Function: deserialize
-Description: Deserializes a SerializedJobCard record into a JobCard object.
+Description: Deserializes a CSV-formatted string into a JobCard object.
 Parameters:
-    - serializedJobCard: const SerializedJobCard&, serialized job card record
+    - record: const std::string&, serialized job card record
 Returns:
    - JobCard*: Pointer to the deserialized JobCard object
+Throws:
+    - std::runtime_error if timestamp parsing fails
 */
-JobCard* JobCard::deserialize(const SerializedJobCard& serializedJobCard)
+JobCard* JobCard::deserialize(const std::string& record)
 {
+    std::string id, bookingId, serviceId, technicianId;
+    std::string assignedDateString, statusString, completionDateString;
+    std::istringstream serializedJobCard(record);
+    getline(serializedJobCard, id, ',');
+    getline(serializedJobCard, bookingId, ',');
+    getline(serializedJobCard, serviceId, ',');
+    getline(serializedJobCard, technicianId, ',');
+    getline(serializedJobCard, assignedDateString, ',');
+    getline(serializedJobCard, statusString, ',');
+    getline(serializedJobCard, completionDateString, ',');
+    util::Timestamp assignedDate;
+    util::Timestamp completionDate;
+    try
+    {
+        assignedDate = util::Timestamp::fromString(assignedDateString);
+        completionDate = util::Timestamp::fromString(completionDateString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid timestamp");
+    }
+    util::ServiceJobStatus status = util::getServiceJobStatus(statusString);
    return Factory::getObject<JobCard>(
-        serializedJobCard.id,
-        serializedJobCard.bookingId,
-        serializedJobCard.serviceId,
-        serializedJobCard.technicianId,
-        serializedJobCard.assignedDate,
-        serializedJobCard.status,
-        serializedJobCard.completionDate);
+        id,
+        bookingId,
+        serviceId,
+        technicianId,
+        assignedDate,
+        status,
+        completionDate
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for job card serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,BookingID,ServiceID,TechnicianID,AssignedDate,Status,CompletionDate")
+*/
+std::string JobCard::getHeaders()
+{
+    return "ID,BookingID,ServiceID,TechnicianID,AssignedDate,Status,CompletionDate";
 }
@@ -15,7 +15,6 @@ Date:19-May-2026
 class ServiceBooking;
 class Service;
 class User;
-struct SerializedJobCard;

 class JobCard
 {
@@ -71,6 +70,7 @@ public:
    void setAssignedDate(const util::Timestamp& assignedDate);
    void setStatus(util::ServiceJobStatus status);
    void setCompletionDate(const util::Timestamp& completionDate);
-    SerializedJobCard serialize() const;
-    static JobCard* deserialize(const SerializedJobCard&);
+    std::string serialize() const;
+    static JobCard* deserialize(const std::string&);
+    static std::string getHeaders();
 };
@@ -8,7 +8,6 @@ Date: 19-May-2026
 */

 #include <sstream>
-#include "SerializedRecords.h"
 #include "Service.h"
 #include "InventoryItem.h"
 #include "StringHelper.h"
@@ -28,8 +27,7 @@ Returns:
 Service::Service()
    : m_id("SRV" + std::to_string(++m_uid)),
    m_status(util::State::ACTIVE),
-    m_laborCost(0.0) {
-}
+    m_laborCost(0.0) {}

 /*
 Function: Service
@@ -268,38 +266,72 @@ static util::Vector<std::string> getInventoryItemIDsAsVector(const std::string&

 /*
 Function: serialize
-Description: Serializes the Service object into a SerializedService record.
+Description: Serializes the service into a CSV-formatted string.
 Parameters:
    - None
 Returns:
-    - SerializedService: Serialized representation of the service
+    - std::string: Serialized service record
 */
-SerializedService Service::serialize() const
+std::string Service::serialize() const
 {
-    SerializedService serialized = {};
-    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
-    strcpy_s(serialized.name, sizeof(serialized.name), m_name.c_str());
-    strcpy_s(serialized.inventoryItemIDs, sizeof(serialized.inventoryItemIDs), getInventoryItemIDsAsString(m_requiredInventoryItemIDs).c_str());
-    serialized.laborCost = m_laborCost;
-    serialized.status = m_status;
-    return serialized;
+    std::ostringstream serializedService;
+    serializedService << m_id << ','
+        << m_name << ','
+        << getInventoryItemIDsAsString(m_requiredInventoryItemIDs) << ','
+        << m_laborCost << ','
+        << util::getStateString(m_status);
+    return serializedService.str();
 }

 /*
 Function: deserialize
-Description: Deserializes a SerializedService record into a Service object.
+Description: Deserializes a CSV-formatted string into a Service object.
 Parameters:
-    - serializedService: const SerializedService&, serialized service record
+    - record: const std::string&, serialized service record
 Returns:
    - Service*: Pointer to the deserialized Service object
+Throws:
+    - std::runtime_error if labor cost parsing fails
 */
-Service* Service::deserialize(const SerializedService& serializedService)
+Service* Service::deserialize(const std::string& record)
 {
-    util::Vector<std::string> inventoryItemIDs = getInventoryItemIDsAsVector(serializedService.inventoryItemIDs);
+    std::string id, name;
+    std::string inventoryItemIDsString, laborCostString, statusString;
+    double laborCost;
+    std::istringstream serializedService(record);
+    getline(serializedService, id, ',');
+    getline(serializedService, name, ',');
+    getline(serializedService, inventoryItemIDsString, ',');
+    getline(serializedService, laborCostString, ',');
+    getline(serializedService, statusString, ',');
+    util::Vector<std::string> inventoryItemIDs = getInventoryItemIDsAsVector(inventoryItemIDsString);
+    try
+    {
+        laborCost = std::stod(laborCostString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid labor cost");
+    }
+    util::State status = util::getState(statusString);
    return Factory::getObject<Service>(
-        serializedService.id,
-        serializedService.name,
+        id,
+        name,
        inventoryItemIDs,
-        serializedService.laborCost,
-        serializedService.status);
+        laborCost,
+        status
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for service serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,Name,InventoryIDs,LaborCost,Status")
+*/
+std::string Service::getHeaders()
+{
+    return "ID,Name,InventoryIDs,LaborCost,Status";
 }
@@ -6,6 +6,7 @@ Author: Trenser
 Date: 19-May-2026
 */

+
 #pragma once
 #include <string>
 #include "Map.h"
@@ -13,7 +14,6 @@ Date: 19-May-2026
 #include "Enums.h"

 class InventoryItem;
-struct SerializedService;

 class Service
 {
@@ -40,6 +40,7 @@ public:
    void setRequiredInventoryItems(const util::Map<std::string, InventoryItem*>& requiredInventoryItems);
    void setLaborCost(double laborCost);
    void setState(util::State status);
-    SerializedService serialize() const;
-    static Service* deserialize(const SerializedService&);
+    std::string serialize() const;
+    static Service* deserialize(const std::string&);
+    static std::string getHeaders();
 };
@@ -6,10 +6,8 @@ Description: Implementation file containing the method definitions of the
 Author: Trenser
 Date:19-May-2026
 */
-
 #include <stdexcept>
 #include <sstream>
-#include "SerializedRecords.h"
 #include "ServiceBooking.h"
 #include "Service.h"
 #include "Enums.h"
@@ -30,8 +28,7 @@ ServiceBooking::ServiceBooking()
    m_customer(nullptr),
    m_assignedTechnician(nullptr),
    m_status(util::ServiceJobStatus::PENDING),
-    m_discountPercentage(0.0) {
-}
+    m_discountPercentage(0.0) {}

 /*
 Function: ServiceBooking
@@ -440,46 +437,84 @@ static util::Vector<std::string> getServiceIDsAsVector(const std::string& servic

 /*
 Function: serialize
-Description: Serializes the ServiceBooking object into a SerializedServiceBooking record.
+Description: Serializes the service booking into a CSV-formatted string.
 Parameters:
    - None
 Returns:
-    - SerializedServiceBooking: Serialized representation of the service booking
+    - std::string: Serialized booking record
 */
-SerializedServiceBooking ServiceBooking::serialize() const
+std::string ServiceBooking::serialize() const
 {
-    SerializedServiceBooking serialized = {};
-    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
-    strcpy_s(serialized.serviceIDs, sizeof(serialized.serviceIDs), getServiceIDsAsString(m_serviceIDs).c_str());
-    strcpy_s(serialized.customerId, sizeof(serialized.customerId), m_customerId.c_str());
-    strcpy_s(serialized.vehicleNumber, sizeof(serialized.vehicleNumber), m_vehicleNumber.c_str());
-    strcpy_s(serialized.vehicleBrand, sizeof(serialized.vehicleBrand), m_vehicleBrand.c_str());
-    strcpy_s(serialized.vehicleModel, sizeof(serialized.vehicleModel), m_vehicleModel.c_str());
-    strcpy_s(serialized.assignedTechnicianId, sizeof(serialized.assignedTechnicianId), m_assignedTechnicianId.c_str());
-    serialized.status = m_status;
-    serialized.discountPercentage = m_discountPercentage;
-    return serialized;
+    std::ostringstream serializedBooking;
+    serializedBooking << m_id << ','
+        << util::getServiceJobStatusString(m_status) << ','
+        << getServiceIDsAsString(m_serviceIDs) << ','
+        << m_customerId << ','
+        << m_vehicleNumber << ','
+        << m_vehicleBrand << ','
+        << m_vehicleModel << ','
+        << m_assignedTechnicianId << ','
+        << m_discountPercentage << ',';
+    return serializedBooking.str();
 }

 /*
 Function: deserialize
-Description: Deserializes a SerializedServiceBooking record into a ServiceBooking object.
+Description: Deserializes a CSV-formatted string into a ServiceBooking object.
 Parameters:
-    - serializedServiceBooking: const SerializedServiceBooking&, serialized service booking record
+    - record: const std::string&, serialized booking record
 Returns:
    - ServiceBooking*: Pointer to the deserialized ServiceBooking object
+Throws:
+    - std::runtime_error if discount percentage parsing fails
 */
-ServiceBooking* ServiceBooking::deserialize(const SerializedServiceBooking& serializedServiceBooking)
+ServiceBooking* ServiceBooking::deserialize(const std::string& record)
 {
-    util::Vector<std::string> serviceIDs = getServiceIDsAsVector(serializedServiceBooking.serviceIDs);
+    std::string id, customerId, vehicleNumber, vehicleBrand, vehicleModel, assignedTechnicianId;
+    std::string serviceJobStatusString, serviceIDsString, discountPercentageString;
+    double discountPercentage;
+    std::istringstream serializedBooking(record);
+    getline(serializedBooking, id, ',');
+    getline(serializedBooking, serviceJobStatusString, ',');
+    getline(serializedBooking, serviceIDsString, ',');
+    getline(serializedBooking, customerId, ',');
+    getline(serializedBooking, vehicleNumber, ',');
+    getline(serializedBooking, vehicleBrand, ',');
+    getline(serializedBooking, vehicleModel, ',');
+    getline(serializedBooking, assignedTechnicianId, ',');
+    getline(serializedBooking, discountPercentageString, ',');
+    util::Vector<std::string> serviceIDs = getServiceIDsAsVector(serviceIDsString);
+    try
+    {
+        discountPercentage = std::stod(discountPercentageString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid discount percentage");
+    }
+    util::ServiceJobStatus status = util::getServiceJobStatus(serviceJobStatusString);
    return Factory::getObject<ServiceBooking>(
-        serializedServiceBooking.id,
-        serializedServiceBooking.status,
+        id,
+        status,
        serviceIDs,
-        serializedServiceBooking.customerId,
-        serializedServiceBooking.vehicleNumber,
-        serializedServiceBooking.vehicleBrand,
-        serializedServiceBooking.vehicleModel,
-        serializedServiceBooking.assignedTechnicianId,
-        serializedServiceBooking.discountPercentage);
+        customerId,
+        vehicleNumber,
+        vehicleBrand,
+        vehicleModel,
+        assignedTechnicianId,
+        discountPercentage
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for service booking serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,Status,ServiceIDs,CustomerID,VehicleNumber,VehicleBrand,VehicleModel,AssignedTechnicianID,DiscountPercentage")
+*/
+std::string ServiceBooking::getHeaders()
+{
+    return "ID,Status,ServiceIDs,CustomerID,VehicleNumber,VehicleBrand,VehicleModel,AssignedTechnicianID,DiscountPercentage";
 }
@@ -6,7 +6,6 @@ Description: Header file declaring the ServiceBooking class, which represents
 Author: Trenser
 Date:19-May-2026
 */
-
 #pragma once
 #include <string>
 #include "Map.h"
@@ -15,7 +14,6 @@ Date:19-May-2026

 class Service;
 class User;
-struct SerializedServiceBooking;

 class ServiceBooking
 {
@@ -80,6 +78,7 @@ public:
    void setAssignedTechnicianId(const std::string& assignedTechnicianId);
    void setAssignedTechnician(User* assignedTechnician);
    void setDiscountPercentage(double discountPercentage);
-    SerializedServiceBooking serialize() const;
-    static ServiceBooking* deserialize(const SerializedServiceBooking&);
+    std::string serialize() const;
+    static ServiceBooking* deserialize(const std::string&);
+    static std::string getHeaders();
 };
@@ -10,32 +10,8 @@ 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
@@ -48,35 +24,16 @@ Return type: bool - true if login successful, false otherwise
 */
 bool AuthenticationManagementService::login(const std::string& username, const std::string& password)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUserMap = m_dataStore.getUsers();
-	int trackedUserMapSize = trackedUserMap.getSize();
-	for (int index = 0; index < trackedUserMapSize; index++)
+	util::Map<std::string, User*> users = m_dataStore.getUsers();
+	int usersMapSize = users.getSize();
+	for (int index = 0; index < usersMapSize; index++)
 	{
-		User* user = trackedUserMap.getValueAt(index).data;
+		User* user = users.getValueAt(index);
 		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;
@@ -105,11 +62,7 @@ Return type: void
 */
 void AuthenticationManagementService::logout()
 {
-	m_eventManager.shutdown();
 	m_authenticatedUser = nullptr;
-	m_isAuthorized = false;
-	m_accountDisabledEvent = NULL;
-	m_notificationsAvailableEvent = NULL;
 }

 /*
@@ -121,33 +74,9 @@ 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,8 +9,6 @@ Date:19-May-2026

 #pragma once
 #include <string>
-#include <windows.h>
-#include "EventManager.h"
 #include "DataStore.h"

 class User;
@@ -19,17 +17,11 @@ 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);
 };
@@ -14,13 +14,11 @@ Date: 22-May-2026
 #include "Factory.h"
 #include "InventoryItem.h"
 #include "InventoryManagementService.h"
-#include "AuthenticationManagementService.h"
 #include "Timestamp.h"
 #include "User.h"
 #include "Utility.h"
 #include "Vector.h"
 #include "DataStoreLockGuard.h"
-#include "EventManager.h"

 util::Map<std::string, User*> InventoryManagementService::m_observers{};

@@ -59,19 +57,18 @@ Returns:
 */
 void InventoryManagementService::sendLowStockAlerts()
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInventoryItemsMap = m_dataStore.getInventoryItems();
-	auto& trackedUserMap = m_dataStore.getUsers();
-	if (trackedInventoryItemsMap.isEmpty())
+	auto& inventoryItems = m_dataStore.getInventoryItems();
+	if (inventoryItems.isEmpty())
 	{
 		return;
 	}
-	int inventoryItemsSize = trackedInventoryItemsMap.getSize();
-	int usersMapSize = trackedUserMap.getSize();
+	int inventoryItemsSize = inventoryItems.getSize();
+	auto& usersMap = m_dataStore.getUsers();
+	int usersMapSize = usersMap.getSize();
 	util::Vector<User*> adminUsers;
 	for (int index = 0; index < usersMapSize; index++)
 	{
-		User* user = trackedUserMap.getValueAt(index).data;
+		User* user = usersMap.getValueAt(index);
 		if (user->getUserType() == util::UserType::ADMIN)
 		{
 			adminUsers.push_back(user);
@@ -84,7 +81,7 @@ void InventoryManagementService::sendLowStockAlerts()
 	}
 	for (int index = 0; index < inventoryItemsSize; index++)
 	{
-		InventoryItem* inventoryItem = trackedInventoryItemsMap.getValueAt(index).data;
+		InventoryItem* inventoryItem = inventoryItems.getValueAt(index);
 		if (inventoryItem && inventoryItem->getQuantity() < config::threshold::INVENTORY_LOW_STOCK_THRESHOLD)
 		{
 			sendLowStockAlertsToAdmins(*this, inventoryItem, adminUsers);
@@ -103,12 +100,8 @@ 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);
-	trackedInventoryItemMap.insert(newItem->getId(), util::createNewRecord(newItem));
-	m_dataStore.saveInventoryItems();
+    m_dataStore.getInventoryItems().insert(newItem->getId(), newItem);
 }

 /*
@@ -120,23 +113,16 @@ Return type: void
 */
 void InventoryManagementService::addInventoryItemStock(const std::string& selectedItemId, int quantity)
 {
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
-	int index = trackedInventoryItemMap.find(selectedItemId);
-	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();
+    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);
+        }
+    }
 }

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

 /*
@@ -162,22 +144,15 @@ Return type: void
 */
 void InventoryManagementService::removeInventoryItem(const std::string& inventoryItemID)
 {
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
-	int index = trackedInventoryItemMap.find(inventoryItemID);
-	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();
+    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);
+        }
+    }
 }

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

 /*
@@ -276,7 +243,6 @@ void InventoryManagementService::sendNotification(User* user, const std::string&
 	{
 		return;
 	}
-	auto& trackedNotificationsMap = m_dataStore.getNotifications();
 	Notification* notification = Factory::getObject<Notification>(
 		user->getId(),
 		title,
@@ -286,8 +252,8 @@ void InventoryManagementService::sendNotification(User* user, const std::string&
 	{
 		throw std::runtime_error("Failed to create notification");
 	}
+	auto& trackedNotificationsMap = m_dataStore.getNotifications();
 	trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
 	m_dataStore.saveNotifications();
-	EventManager::sendNotificationAvailableEvent(user->getId());
 }

@@ -15,15 +15,12 @@ Date: 20-May-2026
 #include "Invoice.h"
 #include "JobCard.h"
 #include "PaymentManagementService.h"
-#include "AuthenticationManagementService.h"
-#include "DataStoreLockGuard.h"
 #include "Service.h"
 #include "ServiceBooking.h"
 #include "Timestamp.h"
 #include "User.h"
 #include "Utility.h"
 #include "DataStoreLockGuard.h"
-#include "EventManager.h"

 util::Map<std::string, User*> PaymentManagementService::m_observers{};

@@ -99,7 +96,6 @@ void PaymentManagementService::sendNotification(User* user, const std::string& t
 	{
 		return;
 	}
-	auto& trackedNotificationsMap = m_dataStore.getNotifications();
 	Notification* notification = Factory::getObject<Notification>(
 		user->getId(),
 		title,
@@ -109,9 +105,9 @@ void PaymentManagementService::sendNotification(User* user, const std::string& t
 	{
 		throw std::runtime_error("Failed to create notification");
 	}
+	auto& trackedNotificationsMap = m_dataStore.getNotifications();
 	trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
 	m_dataStore.saveNotifications();
-	EventManager::sendNotificationAvailableEvent(user->getId());
 }

 /*
@@ -125,12 +121,11 @@ Returns:
 */
 void PaymentManagementService::sendPaymentReminders()
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInvoicesMap = m_dataStore.getInvoices();
-	int invoicesMapSize = trackedInvoicesMap.getSize();
+	auto& invoicesMap = m_dataStore.getInvoices();
+	int invoicesMapSize = invoicesMap.getSize();
 	for (int index = 0; index < invoicesMapSize; index++)
 	{
-		const Invoice* invoice = trackedInvoicesMap.getValueAt(index).data;
+		const Invoice* invoice = invoicesMap.getValueAt(index);
 		if (invoice && invoice->getStatus() == util::PaymentStatus::PENDING)
 		{
 			util::Timestamp invoiceCreationTimestamp = invoice->getInvoiceDate();
@@ -186,7 +181,6 @@ Throws:
 */
 void PaymentManagementService::generateInvoice(ServiceBooking* booking)
 {
-	DataStoreLockGuard lock(m_dataStore);
 	if (!booking)
 	{
 		throw std::runtime_error("Invoice generation failed: booking is null.");
@@ -196,10 +190,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;
-	auto& currentTrackedJobCards = m_dataStore.getJobCards();
-	for (int iterator = 0; iterator < currentTrackedJobCards.getSize(); iterator++)
+	util::Map<std::string, JobCard*> currentJobCards = m_dataStore.getJobCards();
+	for (int iterator = 0; iterator < currentJobCards.getSize(); iterator++)
 	{
-		JobCard* currentJobCard = currentTrackedJobCards.getValueAt(iterator).data;
+		JobCard* currentJobCard = currentJobCards.getValueAt(iterator);
 		util::ServiceJobStatus currentJobCardStatus = currentJobCard->getStatus();
 		if (currentJobCard->getBookingId() == bookingID && currentJobCardStatus != util::ServiceJobStatus::CANCELLED && currentJobCardStatus != util::ServiceJobStatus::COMPLETED)
 		{
@@ -219,9 +213,8 @@ 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);
-	auto& currentTrackedInvoices = m_dataStore.getInvoices();
-	currentTrackedInvoices.insert(invoice->getId(), util::createNewRecord(invoice));
-	m_dataStore.saveInvoices();
+	util::Map<std::string, Invoice*>& currentInvoices = m_dataStore.getInvoices();
+	currentInvoices.insert(invoice->getId(), invoice);
 }

 /*
@@ -234,13 +227,11 @@ Returns:
 */
 util::Map<std::string, Invoice*> PaymentManagementService::getInvoices(const std::string& customerID)
 {
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& currentTrackedInvoices = m_dataStore.getInvoices();
+	util::Map<std::string, Invoice*>& currentInvoices = m_dataStore.getInvoices();
 	util::Map<std::string, Invoice*> currentUserInvoices;
-	for (int iterator = 0; iterator < currentTrackedInvoices.getSize(); iterator++)
+	for (int iterator = 0; iterator < currentInvoices.getSize(); iterator++)
 	{
-		Invoice* currentInvoice = currentTrackedInvoices.getValueAt(iterator).data;
+		Invoice* currentInvoice = currentInvoices.getValueAt(iterator);
 		if (currentInvoice->getBooking()->getCustomerId() == customerID)
 		{
 			currentUserInvoices.insert(currentInvoice->getId(), currentInvoice);
@@ -263,14 +254,11 @@ Throws:
 */
 void PaymentManagementService::completePayment(const std::string& invoiceID, util::PaymentMode paymentMode)
 {
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& currentTrackedInvoices = m_dataStore.getInvoices();
-	int invoiceIndex = currentTrackedInvoices.find(invoiceID);
+	auto& currentInvoices = m_dataStore.getInvoices();
+	int invoiceIndex = currentInvoices.find(invoiceID);
 	if (invoiceIndex != -1)
 	{
-		auto& trackedInvoice = currentTrackedInvoices.getValueAt(invoiceIndex);
-		Invoice* invoice = trackedInvoice.data;
+		Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
 		if (invoice && invoice->getStatus() != util::PaymentStatus::PAID)
 		{
 			User* currentUser = invoice->getBooking()->getCustomer();
@@ -281,31 +269,25 @@ 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: getAllInvoices
+Function: getAllInvoice
 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()
 {
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	util::Map<std::string, Invoice*> invoices;
-	invoices = util::getObjects(m_dataStore.getInvoices());
-	return invoices;
+	return m_dataStore.getInvoices();
 }

 /*
@@ -321,25 +303,20 @@ Throws:
 */
 void PaymentManagementService::confirmPayment(const std::string& invoiceID)
 {
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& currentTrackedInvoices = m_dataStore.getInvoices();
-	int invoiceIndex = currentTrackedInvoices.find(invoiceID);
+	auto& currentInvoices = m_dataStore.getInvoices();
+	int invoiceIndex = currentInvoices.find(invoiceID);
 	if (invoiceIndex == -1)
 	{
 		throw std::runtime_error("Payment confirmation failed: invalid invoice ID.");
 	}
-	auto& trackedInvoice = currentTrackedInvoices.getValueAt(invoiceIndex);
-	Invoice* invoice = trackedInvoice.data;
+	Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
 	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();
 }
@@ -27,7 +27,7 @@ public:
    void generateInvoice(ServiceBooking* booking);
    util::Map<std::string, Invoice*> getInvoices(const std::string& customerID);
    void completePayment(const std::string& invoiceID, util::PaymentMode paymentMode);
-    util::Map<std::string, Invoice*> getAllInvoices();
+    util::Map<std::string, Invoice*>& getAllInvoices();
    void confirmPayment(const std::string& invoiceID);
    void sendPaymentReminders();
    void sendNotification(User* user, const std::string& title, const std::string& message) override;
@@ -24,34 +24,8 @@ Date:19-May-2026
 #include "Timestamp.h"
 #include "User.h"
 #include "UserManagementService.h"
-#include "DataStoreLockGuard.h"
 #include "Utility.h"
-#include "EventManager.h"
-
-/*
-Function: notifyAllAdmins
-Description: Sends a notification to all users with the ADMIN role.
-             Iterates through the provided user collection and delivers
-             the specified notification to each administrator using the
-             ServiceManagementService notification mechanism.
-Parameter: const std::string& title - notification title
-Parameter: const std::string& message - notification message
-Parameter: const util::Map<std::string, TrackedRecord<User>>& users - collection of tracked users
-Parameter: ServiceManagementService* serviceManagementService - service used to dispatch notifications
-Return type: void
-*/
-static void notifyAllAdmins(const std::string& title, const std::string& message, const util::Map<std::string, TrackedRecord<User>>& users, ServiceManagementService* serviceManagementService)
-{
-    int numberOfUsers = users.getSize();
-    for (int index = 0; index < numberOfUsers; index++)
-    {
-        User* user = users.getValueAt(index).data;
-        if (user->getUserType() == util::UserType::ADMIN)
-        {
-            serviceManagementService->sendNotification(user, title, message);
-        }
-    }
-}
+#include "DataStoreLockGuard.h"

 /*
 Function: purchaseService
@@ -66,26 +40,24 @@ Return type: void
 */
 void ServiceManagementService::purchaseService(const util::Vector<std::string>& serviceIDs, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
 {
-    AuthenticationManagementService::ensureAuthorization();
 	AuthenticationManagementService m_authenticationManagementService;
 	auto authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
 	if (authenticatedUser == nullptr)
 	{
 		throw std::runtime_error("No user is currently logged in!");
 	}
-    DataStoreLockGuard lock(m_dataStore);
-	auto& trackedServicesMap = m_dataStore.getServices();
-	auto& trackedServiceBookingMap = m_dataStore.getServiceBookings();
+	auto& servicesMap = m_dataStore.getServices();
+	auto& serviceBookingMap = m_dataStore.getServiceBookings();
 	util::Map<std::string, Service*> selectedServices;
 	int selectedServicesCount = serviceIDs.getSize();
 	for (int index = 0; index < selectedServicesCount; index++)
 	{
-		int serviceIndex = trackedServicesMap.find(serviceIDs[index]);
+		int serviceIndex = servicesMap.find(serviceIDs[index]);
 		if (serviceIndex == -1)
 		{
 			throw std::runtime_error("Service not found!");
 		}
-		Service* service = trackedServicesMap.getValueAt(serviceIndex).data;
+		Service* service = servicesMap.getValueAt(serviceIndex);
 		selectedServices[service->getId()] = service;
 	}
 	ServiceBooking* serviceBooking = Factory::getObject<ServiceBooking>(util::ServiceJobStatus::PENDING, selectedServices, authenticatedUser->getId(), authenticatedUser, vehicleNumber, vehicleBrand, vehicleModel, 0);
@@ -93,12 +65,10 @@ void ServiceManagementService::purchaseService(const util::Vector<std::string>&
 	{
 		throw std::runtime_error("Failed to create service booking");
 	}
-	trackedServiceBookingMap[serviceBooking->getId()] =  util::createNewRecord(serviceBooking);
+	serviceBookingMap[serviceBooking->getId()] = serviceBooking;
    std::string title = "Service Booking succeeded";
    std::string message = "Your service booking has been successfully placed with ID " + serviceBooking->getId();
    sendNotification(authenticatedUser, title, message);
-    m_dataStore.saveServiceBookings();
-    notifyAllAdmins("New Service Order Available", "A new service order has been placed with Service Booking ID " + serviceBooking->getId(), m_dataStore.getUsers(), this);
 }

 /*
@@ -114,34 +84,30 @@ Return type: void
 */
 void ServiceManagementService::purchaseComboPackage(const std::string& comboPackageID, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
 {
-    AuthenticationManagementService::ensureAuthorization();
 	AuthenticationManagementService m_authenticationManagementService;
 	auto authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
 	if (authenticatedUser == nullptr)
 	{
 		throw std::runtime_error("No user is currently logged in!");
 	}
-    DataStoreLockGuard lock(m_dataStore);
-	auto& trackedComboPackagesMap = m_dataStore.getComboPackages();
-	auto& trackedServiceBookingMap = m_dataStore.getServiceBookings();
-	int comboPackageIndex = trackedComboPackagesMap.find(comboPackageID);
+	auto& comboPackagesMap = m_dataStore.getComboPackages();
+	auto& serviceBookingMap = m_dataStore.getServiceBookings();
+	int comboPackageIndex = comboPackagesMap.find(comboPackageID);
 	if (comboPackageIndex == -1)
 	{
 		throw std::runtime_error("Combo Package not found!");
 	}
-	const ComboPackage* comboPackage = trackedComboPackagesMap[comboPackageID].data;
+	const ComboPackage* comboPackage = comboPackagesMap[comboPackageID];
 	util::Map<std::string, Service*> selectedServices = comboPackage->getServices();
 	ServiceBooking* serviceBooking = Factory::getObject<ServiceBooking>(util::ServiceJobStatus::PENDING, selectedServices, authenticatedUser->getId(), authenticatedUser, vehicleNumber, vehicleBrand, vehicleModel, comboPackage->getDiscountPercentage());
 	if (serviceBooking == nullptr)
 	{
 		throw std::runtime_error("Failed to create combo package service booking");
 	}
-	trackedServiceBookingMap[serviceBooking->getId()] = util::createNewRecord(serviceBooking);
+	serviceBookingMap[serviceBooking->getId()] = serviceBooking;
    std::string title = "Combo Package Service Booking succeeded";
    std::string message = "Your service booking for the combo package has been successfully placed with ID " + serviceBooking->getId();
    sendNotification(authenticatedUser, title, message);
-    m_dataStore.saveServiceBookings();
-    notifyAllAdmins("New Combo Package Order Available", "A new combo package order has been placed with Service Booking ID " + serviceBooking->getId(), m_dataStore.getUsers(), this);
 }

 util::Map<std::string, User*> ServiceManagementService::m_observers{};
@@ -218,7 +184,6 @@ void ServiceManagementService::sendNotification(User* user, const std::string& t
    {
        return;
    }
-    auto& trackedNotificationsMap = m_dataStore.getNotifications();
    Notification* notification = Factory::getObject<Notification>(
        user->getId(),
        title,
@@ -228,9 +193,9 @@ void ServiceManagementService::sendNotification(User* user, const std::string& t
    {
        throw std::runtime_error("Failed to create notification");
    }
+    auto& trackedNotificationsMap = m_dataStore.getNotifications();
    trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
    m_dataStore.saveNotifications();
-    EventManager::sendNotificationAvailableEvent(user->getId());
 }

 /*
@@ -240,7 +205,7 @@ Description: Restores inventory quantities for all required items in the service
 Parameter: ServiceBooking* booking - Pointer to the booking whose inventory items need to be restored
 Return type: void
 */
-static void restoreInventory(ServiceBooking* booking, util::Map<std::string, TrackedRecord<InventoryItem>>& trackedInventoryItems)
+static void restoreInventory(ServiceBooking* booking)
 {
    const int INCREMENT_VALUE = 1;
    if (!booking) 
@@ -259,17 +224,9 @@ static void restoreInventory(ServiceBooking* booking, util::Map<std::string, Tra
        for (int InventoryIterator = 0; InventoryIterator < items.getSize(); ++InventoryIterator)
        {
            InventoryItem* item = items.getValueAt(InventoryIterator);
-            const std::string& currentItemId = item->getId();
-            int itemIndex = trackedInventoryItems.find(currentItemId);
-            if (itemIndex == -1)
-            {
-                continue;
-            }
-            auto& currentTrackedInventoryItem = trackedInventoryItems.getValueAt(itemIndex);
            if (item)
            {
                item->setQuantity(item->getQuantity() + INCREMENT_VALUE);
-                currentTrackedInventoryItem.state = RecordState::MODIFIED;
            }
        }
    }
@@ -287,28 +244,23 @@ Parameters:
    util::UserType userType - Type of user initiating cancellation (CUSTOMER or TECHNICIAN)
 Return type: void
 */
-static void processBookingCancellation(TrackedRecord<ServiceBooking>& trackedBooking,
-    util::Map<std::string, TrackedRecord<JobCard>>& jobs,
+static void processBookingCancellation(ServiceBooking* booking,
+    util::Map<std::string, JobCard*>& jobs,
    ServiceManagementService& currentService,
-    util::UserType userType,
-    util::Map<std::string, TrackedRecord<InventoryItem>>& trackedInventoryItems)
+    util::UserType userType)
 {
-    ServiceBooking* booking = trackedBooking.data;
    if (!booking)
    {
        return;
    }
-    const std::string& bookingId = booking->getId();
    for (int jobIterator = 0; jobIterator < jobs.getSize(); ++jobIterator)
    {
-        auto& trackedJobCard = jobs.getValueAt(jobIterator);
-        JobCard* jobCard = trackedJobCard.data;
+        JobCard* jobCard = jobs.getValueAt(jobIterator);
        if (!jobCard || jobCard->getBookingId() != booking->getId() || jobCard->getStatus() == util::ServiceJobStatus::CANCELLED)
        {
            continue;
        }
        jobCard->setStatus(util::ServiceJobStatus::CANCELLED);
-        trackedJobCard.state = RecordState::MODIFIED;
        if (userType == util::UserType::CUSTOMER)
        {
            if (User* technician = booking->getAssignedTechnician())
@@ -341,8 +293,7 @@ static void processBookingCancellation(TrackedRecord<ServiceBooking>& trackedBoo
    }
    booking->setAssignedTechnician(nullptr);
    booking->setAssignedTechnicianId("");
-    trackedBooking.state = RecordState::MODIFIED;
-    restoreInventory(booking, trackedInventoryItems);
+    restoreInventory(booking);
 }

 /*
@@ -355,25 +306,22 @@ Return type: void
 */
 void ServiceManagementService::cancelCustomerServiceBookings(const std::string& customerID)
 {
-    DataStoreLockGuard lock(m_dataStore);
-    auto& trackedUsers = m_dataStore.getUsers();
-    int userIndex = trackedUsers.find(customerID);
+    auto& users = m_dataStore.getUsers();
+    int userIndex = users.find(customerID);
    if (userIndex == -1)
    {
        throw std::runtime_error("User not found: " + customerID);
    }
-    User* customer = trackedUsers.getValueAt(userIndex).data;
+    User* customer = users.getValueAt(userIndex);
    if (!customer)
    {
        throw std::runtime_error("User not found: " + customerID);
    }
-    auto& trackedBookings = m_dataStore.getServiceBookings();
-    auto& trackedJobs = m_dataStore.getJobCards();
-    auto& trackedInventoryItems = m_dataStore.getInventoryItems();
-    for (int iteratorOne = 0; iteratorOne < trackedBookings.getSize(); iteratorOne++)
+    auto& bookings = m_dataStore.getServiceBookings();
+    auto& jobs = m_dataStore.getJobCards();
+    for (int iteratorOne = 0; iteratorOne < bookings.getSize(); iteratorOne++)
    {
-        auto& trackedBooking = trackedBookings.getValueAt(iteratorOne);
-        ServiceBooking* booking = trackedBooking.data;
+        ServiceBooking* booking = bookings.getValueAt(iteratorOne);
        if (!booking)
        {
            continue;
@@ -388,12 +336,8 @@ void ServiceManagementService::cancelCustomerServiceBookings(const std::string&
        {
            continue;
        }
-        processBookingCancellation(trackedBooking, trackedJobs, *this, util::UserType::CUSTOMER, trackedInventoryItems);
+        processBookingCancellation(booking, jobs, *this, util::UserType::CUSTOMER);
    }
-    m_dataStore.saveUsers();
-    m_dataStore.saveServiceBookings();
-    m_dataStore.saveJobCards();
-    m_dataStore.saveInventoryItems();
 }

 /*
@@ -405,25 +349,22 @@ Return type: void
 */
 void ServiceManagementService::cancelTechnicianJobs(const std::string& technicianID)
 {
-    DataStoreLockGuard lock(m_dataStore);
-    auto& trackedUsers = m_dataStore.getUsers();
-    int userIndex = trackedUsers.find(technicianID);
+    auto& users = m_dataStore.getUsers();
+    int userIndex = users.find(technicianID);
    if (userIndex == -1)
    {
        throw std::runtime_error("User not found: " + technicianID);
    }
-    User* technician = trackedUsers.getValueAt(userIndex).data;
+    User* technician = users.getValueAt(userIndex);
    if (!technician)
    {
        throw std::runtime_error("User not found: " + technicianID);
    }
-    auto& trackedBookings = m_dataStore.getServiceBookings();
-    auto& trackedJobs = m_dataStore.getJobCards();
-    auto& trackedInventoryItems = m_dataStore.getInventoryItems();
-    for (int iteratorOne = 0; iteratorOne < trackedBookings.getSize(); iteratorOne++)
+    auto& bookings = m_dataStore.getServiceBookings();
+    auto& jobs = m_dataStore.getJobCards();
+    for (int iteratorOne = 0; iteratorOne < bookings.getSize(); iteratorOne++)
    {
-        auto& trackedBooking = trackedBookings.getValueAt(iteratorOne);
-        ServiceBooking* booking = trackedBooking.data;
+        ServiceBooking* booking = bookings.getValueAt(iteratorOne);
        if (!booking)
        {
            continue;
@@ -444,12 +385,8 @@ void ServiceManagementService::cancelTechnicianJobs(const std::string& technicia
        {
            continue;
        }
-        processBookingCancellation(trackedBooking, trackedJobs, *this, util::UserType::TECHNICIAN, trackedInventoryItems);
+        processBookingCancellation(booking, jobs, *this, util::UserType::TECHNICIAN);
    }
-    m_dataStore.saveUsers();
-    m_dataStore.saveInventoryItems();
-    m_dataStore.saveServiceBookings();
-    m_dataStore.saveJobCards();
 }

 /*
@@ -463,8 +400,6 @@ Return type: void
 */
 void ServiceManagementService::createComboPackage(const std::string& packageName, const util::Vector<std::string>& serviceIDsInNewCombo, double discountPercentage)
 {
-    AuthenticationManagementService::ensureAuthorization();
-    DataStoreLockGuard lock(m_dataStore);
    if (packageName.empty())
    {
        throw std::invalid_argument("The Combo Package Name cannot be empty.\n");
@@ -477,19 +412,19 @@ void ServiceManagementService::createComboPackage(const std::string& packageName
    {
        throw std::invalid_argument("Discount percentage must be between 0 and 100.");
    }
-    auto& trackedServicesMap = m_dataStore.getServices();
+    auto& servicesMap = m_dataStore.getServices();
    for (int index = 0; index < serviceIDsInNewCombo.getSize(); index++)
    {
-        const std::string& serviceid = serviceIDsInNewCombo[index];
-        if (trackedServicesMap.find(serviceid) == -1)
+        const std::string serviceid = serviceIDsInNewCombo[index];
+        if (servicesMap.find(serviceid) == -1)
        {
            throw std::runtime_error("Service ID not found: " + serviceid);
        }
    }
-    auto& trackedComboPackageMap = m_dataStore.getComboPackages();
-    for (int iterator = 0; iterator < trackedComboPackageMap.getSize(); iterator++)
+    auto& comboPackageMap = m_dataStore.getComboPackages();
+    for (int iterator = 0; iterator < comboPackageMap.getSize(); iterator++)
    {
-        ComboPackage* existingCombos = trackedComboPackageMap.getValueAt(iterator).data;
+        ComboPackage* existingCombos = comboPackageMap.getValueAt(iterator);
        const util::Map<std::string, Service*>& servicesInsideExistingCombos = existingCombos->getServices();
        if (servicesInsideExistingCombos.getSize() == serviceIDsInNewCombo.getSize())
        {
@@ -513,16 +448,15 @@ void ServiceManagementService::createComboPackage(const std::string& packageName
    for (int iteratorOne = 0; iteratorOne < serviceIDsInNewCombo.getSize(); iteratorOne++)
    {
        const std::string& serviceId = serviceIDsInNewCombo[iteratorOne];
-        int serviceIndex = trackedServicesMap.find(serviceId);
+        int serviceIndex = servicesMap.find(serviceId);
        if (serviceIndex == -1)
        {
            throw std::runtime_error("Service ID not found: " + serviceId);
        }
-        selectedServices.insert(serviceId, trackedServicesMap.getValueAt(serviceIndex).data);
+        selectedServices.insert(serviceId, servicesMap.getValueAt(serviceIndex));
    }
    ComboPackage* newComboPackage = Factory::getObject<ComboPackage>(packageName, discountPercentage, selectedServices);
-    trackedComboPackageMap.insert(newComboPackage->getId(), util::createNewRecord(newComboPackage));
-    m_dataStore.saveComboPackages();
+    comboPackageMap.insert(newComboPackage->getId(), newComboPackage);
 }

 /*
@@ -533,11 +467,7 @@ Return type: util::Map<std::string, ComboPackage*>
 */
 util::Map<std::string, ComboPackage*> ServiceManagementService::getComboPackages()
 {
-    AuthenticationManagementService::ensureAuthorization();
-    DataStoreLockGuard lock(m_dataStore);
-    util::Map<std::string, ComboPackage*> comboPackages;
-    comboPackages = util::getObjects(m_dataStore.getComboPackages());
-    return comboPackages;
+    return m_dataStore.getComboPackages();
 }

 /*
@@ -548,18 +478,14 @@ Return type: void
 */
 void ServiceManagementService::removeComboPackage(const std::string& comboPackageID)
 {
-    AuthenticationManagementService::ensureAuthorization();
-    DataStoreLockGuard lock(m_dataStore);
    bool removed = false;
-    auto& trackedComboPackages = m_dataStore.getComboPackages();
-    for (int iterator = 0; iterator < trackedComboPackages.getSize(); iterator++)
+    util::Map<std::string, ComboPackage*>& currentComboPackages = m_dataStore.getComboPackages();
+    for (int iterator = 0; iterator < currentComboPackages.getSize(); iterator++)
    {
-        auto& comboPackage = trackedComboPackages.getValueAt(iterator);
-        ComboPackage* currentComboPackage = comboPackage.data;
+        ComboPackage* currentComboPackage = currentComboPackages.getValueAt(iterator);
        if (currentComboPackage && currentComboPackage->getId() == comboPackageID)
        {
            currentComboPackage->setState(util::State::INACTIVE);
-            comboPackage.state = RecordState::MODIFIED;
            removed = true;
            break;
        }
@@ -568,7 +494,6 @@ void ServiceManagementService::removeComboPackage(const std::string& comboPackag
    {
        throw std::runtime_error("Combo package with ID '" + comboPackageID + "' not found.");
    }
-    m_dataStore.saveComboPackages();
 }

 /*
@@ -581,11 +506,7 @@ Returns:
 */
 util::Map<std::string, ServiceBooking*> ServiceManagementService::getServiceBookings()
 {
-    AuthenticationManagementService::ensureAuthorization();
-    DataStoreLockGuard lock(m_dataStore);
-    util::Map<std::string, ServiceBooking*> serviceBookings;
-    serviceBookings = util::getObjects(m_dataStore.getServiceBookings());
-    return serviceBookings;
+	return m_dataStore.getServiceBookings();
 }

 /*
@@ -598,7 +519,6 @@ Returns:
 */
 ServiceBooking* ServiceManagementService::getServiceBooking(const std::string& serviceID)
 {
-    AuthenticationManagementService::ensureAuthorization();
 	auto currentServiceBookings = getServiceBookings();
 	for (int iterator = 0; iterator < currentServiceBookings.getSize(); iterator++)
 	{
@@ -625,27 +545,13 @@ Throws:
 */
 void ServiceManagementService::createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID)
 {
-    AuthenticationManagementService::ensureAuthorization();
-    DataStoreLockGuard lock(m_dataStore);
 	UserManagementService m_userManagementService;
 	ServiceBooking* currentBooking = getServiceBooking(bookingID);
-    if (currentBooking == nullptr)
-    {
-        throw std::runtime_error("Service Booking not available");
-    }
-    if (currentBooking->getStatus() == util::ServiceJobStatus::CANCELLED)
-    {
-        throw std::runtime_error("Cannot create job card. Service Booking was cancelled!");
-    }
-	auto& currentTrackedJobCards = m_dataStore.getJobCards();
-    auto& currentTrackedInventoryItems = m_dataStore.getInventoryItems();
-    auto& currentTrackedServiceBookings = m_dataStore.getServiceBookings();
-    int currentTrackedServiceBookingIndex = currentTrackedServiceBookings.find(bookingID);
-    if (currentTrackedServiceBookingIndex == -1)
-    {
-        throw std::runtime_error("Invalid service booking id.");
-    }
-    auto& currentTrackedServiceBooking = currentTrackedServiceBookings.getValueAt(currentTrackedServiceBookingIndex);
+	auto& currentJobCards = m_dataStore.getJobCards();
+	if (currentBooking == nullptr)
+	{
+		throw std::runtime_error("Service Booking not available");
+	}
 	auto& currentServices = currentBooking->getServices();
 	if (currentServices.find(serviceID) == -1)
 	{
@@ -670,18 +576,10 @@ void ServiceManagementService::createJobCard(const std::string& bookingID, const
 	for (int iterator = 0; iterator < inventoryItems.getSize(); iterator++)
 	{
 		InventoryItem* currentInventoryItem = inventoryItems.getValueAt(iterator);
-        const std::string& currentInventoryItemId = inventoryItems.getKeyAt(iterator);
 		if (currentInventoryItem)
 		{
-            int trackedCurrentInventoryItemIndex = currentTrackedInventoryItems.find(currentInventoryItemId);
-            if (trackedCurrentInventoryItemIndex == -1)
-            {
-                throw std::runtime_error("Invalid inventory item index.");
-            }
-            auto& trackedCurrentInventoryItem = currentTrackedInventoryItems.getValueAt(trackedCurrentInventoryItemIndex);
 			int currentStockQuantity = currentInventoryItem->getQuantity();
 			currentInventoryItem->setQuantity(currentStockQuantity - 1);
-            trackedCurrentInventoryItem.state = RecordState::MODIFIED;
 		}
 	}
 	currentBooking->setAssignedTechnician(selectedTechnician);
@@ -690,13 +588,12 @@ void ServiceManagementService::createJobCard(const std::string& bookingID, const
    {
        currentBooking->setStatus(util::ServiceJobStatus::STARTED);
    }
-    currentTrackedServiceBooking.state = RecordState::MODIFIED;
 	std::string title = "Job card created";
 	std::string message = "Job card created for the service and you are assigned for that.";
 	JobCard* jobCard = Factory::getObject<JobCard>(bookingID, currentBooking, currentService, serviceID, technicianID, selectedTechnician, util::Timestamp(), util::ServiceJobStatus::STARTED, util::Timestamp());
 	if (jobCard)
 	{
-		currentTrackedJobCards.insert(jobCard->getId(), util::createNewRecord(jobCard));
+		currentJobCards.insert(jobCard->getId(), jobCard);
 		sendNotification(selectedTechnician, title, message);
 	}
 	else
@@ -706,9 +603,6 @@ void ServiceManagementService::createJobCard(const std::string& bookingID, const
    title = "Technician assigned";
    message = "A technician has been assigned to your Service Booking with ID " + bookingID;
    sendNotification(currentBooking->getCustomer(), title, message);
-    m_dataStore.saveJobCards();
-    m_dataStore.saveServiceBookings();
-    m_dataStore.saveInventoryItems();
 }

 /*
@@ -726,18 +620,15 @@ Throws:
 */
 void ServiceManagementService::createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost)
 {
-    AuthenticationManagementService::ensureAuthorization();
-    DataStoreLockGuard lock(m_dataStore);
 	util::Map<std::string, InventoryItem*> currentServiceInventoryItems;
-	auto& trackedInventoryItems = m_dataStore.getInventoryItems();
-    auto& currentServices = m_dataStore.getServices();
+	auto inventoryItems = m_dataStore.getInventoryItems();
 	for (int iteratorOne =0; iteratorOne < inventoryItemIDs.getSize(); iteratorOne++)
 	{
 		std::string currentItemID = inventoryItemIDs[iteratorOne];
 		bool itemFound = false;
-		for (int iteratorTwo = 0; iteratorTwo < trackedInventoryItems.getSize(); iteratorTwo++)
+		for (int iteratorTwo = 0; iteratorTwo < inventoryItems.getSize(); iteratorTwo++)
 		{
-			InventoryItem* currentInventoryItem = trackedInventoryItems.getValueAt(iteratorTwo).data;
+			InventoryItem* currentInventoryItem = inventoryItems.getValueAt(iteratorTwo);
 			if (currentInventoryItem && currentInventoryItem->getId() == currentItemID)
 			{
 				itemFound = true;
@@ -755,12 +646,12 @@ void ServiceManagementService::createService(const std::string& name, const util
 	{
 		throw std::runtime_error("Unable to create new service.");
 	}
+	util::Map<std::string, Service*>& currentServices = m_dataStore.getServices();
 	if (currentServices.find(newService->getId()) != -1)
 	{
 		throw std::runtime_error("Service with this ID Already exists.");
 	}
-	currentServices.insert(newService->getId(), util::createNewRecord(newService));
-    m_dataStore.saveServices();
+	currentServices.insert(newService->getId(), newService);
 }

 /*
@@ -773,11 +664,7 @@ Returns:
 */
 util::Map<std::string, Service*> ServiceManagementService::getServices()
 {
-    AuthenticationManagementService::ensureAuthorization();
-    DataStoreLockGuard lock(m_dataStore);
-    util::Map<std::string, Service*> services;
-    services = util::getObjects(m_dataStore.getServices());
-    return services;
+	return m_dataStore.getServices();
 }

 /*
@@ -792,20 +679,14 @@ Throws:
 */
 void ServiceManagementService::removeService(const std::string& serviceID)
 {
-    AuthenticationManagementService::ensureAuthorization();
-    DataStoreLockGuard lock(m_dataStore);
-	auto& currentTrackedServices = m_dataStore.getServices();
-    auto& currentTrackedComboPackages =  m_dataStore.getComboPackages();
-	if (currentTrackedServices.find(serviceID) != -1)
+	util::Map<std::string, Service*>& currentServices = m_dataStore.getServices();
+    util::Map<std::string, ComboPackage*>& currentComboPackages =  m_dataStore.getComboPackages();
+	if (currentServices.find(serviceID) != -1)
 	{
-        int serviceIndex, comboPackageIndex;
-        serviceIndex = currentTrackedServices.find(serviceID);
-		currentTrackedServices.getValueAt(serviceIndex).data->setState(util::State::INACTIVE);
-        currentTrackedServices.getValueAt(serviceIndex).state = RecordState::MODIFIED;
-        for (int iterator = 0; iterator < currentTrackedComboPackages.getSize(); iterator++)
+		currentServices.getValueAt(currentServices.find(serviceID))->setState(util::State::INACTIVE);
+        for (int iterator = 0; iterator < currentComboPackages.getSize(); iterator++)
        {
-            comboPackageIndex = iterator;
-            ComboPackage* currentComboPackage = currentTrackedComboPackages.getValueAt(iterator).data;
+            ComboPackage* currentComboPackage = currentComboPackages.getValueAt(iterator);
            if (currentComboPackage && currentComboPackage->getState() == util::State::ACTIVE)
            {
                util::Map<std::string, Service*> currentServices = currentComboPackage->getServices();
@@ -815,7 +696,6 @@ void ServiceManagementService::removeService(const std::string& serviceID)
                    if (currentService->getId() == serviceID)
                    {
                        currentComboPackage->setState(util::State::INACTIVE);
-                        currentTrackedComboPackages.getValueAt(comboPackageIndex).state = RecordState::MODIFIED;
                        break;
                    }
                }
@@ -826,63 +706,6 @@ void ServiceManagementService::removeService(const std::string& serviceID)
 	{
 		throw std::runtime_error("Service not found.");
 	}
-    m_dataStore.saveServices();
-    m_dataStore.saveComboPackages();
-}
-
-/*
-Function: removeServiceBooking
-Description: Removes a pending service booking by its ID.
-             Cancels only if status is PENDING, otherwise throws exceptions
-             for invalid states. Sends notification to the customer and
-             persists changes.
-Parameter: const std::string& bookingID - ID of the service booking
-Return type: void
-*/
-void ServiceManagementService::removeServiceBooking(const std::string& bookingID)
-{
-    DataStoreLockGuard lock(m_dataStore);
-    auto& trackedServiceBookings = m_dataStore.getServiceBookings();
-    bool serviceBookingRemoved = false;
-    for (int iterator = 0; iterator < trackedServiceBookings.getSize(); iterator++)
-    {
-        auto& currentTrackedServiceBooking = trackedServiceBookings.getValueAt(iterator);
-        ServiceBooking* currentServiceBooking = currentTrackedServiceBooking.data;
-        if (currentServiceBooking && currentServiceBooking->getId() == bookingID)
-        {
-            if (currentServiceBooking->getStatus() == util::ServiceJobStatus::PENDING)
-            {
-                const std::string title = "Service Booking cancelled.";
-                const std::string message = "Service Booking of id " + bookingID + " successfully cancelled.";
-                currentServiceBooking->setStatus(util::ServiceJobStatus::CANCELLED);
-                currentTrackedServiceBooking.state = RecordState::MODIFIED;
-                serviceBookingRemoved = true;
-                sendNotification(currentServiceBooking->getCustomer(), title, message);
-                break;
-            }
-            else if(currentServiceBooking->getStatus() == util::ServiceJobStatus::COMPLETED)
-            {
-                throw std::runtime_error("Unable to cancel completed service booking.");
-            }
-            else if (currentServiceBooking->getStatus() == util::ServiceJobStatus::STARTED)
-            {
-                throw std::runtime_error("Unable to cancel started service booking.");
-            }
-            else if (currentServiceBooking->getStatus() == util::ServiceJobStatus::IN_PROGRESS)
-            {
-                throw std::runtime_error("Unable to cancel currently Inprogress service booking.");
-            }
-            else
-            {
-                throw std::runtime_error("Service Booking already cancelled.");
-            }
-        }
-    }
-    if (!serviceBookingRemoved)
-    {
-        throw std::runtime_error("Unable to cancel service booking.");
-    }
-    m_dataStore.saveServiceBookings();
 }

 /*
@@ -895,7 +718,6 @@ Returns:
 */
 util::Map<std::string, ServiceBooking*> ServiceManagementService::getServiceBookings(const std::string& customerID)
 {
-    AuthenticationManagementService::ensureAuthorization();
 	util::Map<std::string, ServiceBooking*> currentServiceBookings = getServiceBookings();
 	util::Map<std::string, ServiceBooking*> currentUserServiceBookings;
 	if (currentServiceBookings.getSize() != 0)
@@ -922,13 +744,11 @@ Returns:
 */
 util::Map<std::string, JobCard*> ServiceManagementService::getJobCards(const std::string& technicianID)
 {
-    AuthenticationManagementService::ensureAuthorization();
-    DataStoreLockGuard lock(m_dataStore);
-	auto& trackedJobCards = m_dataStore.getJobCards();
+	util::Map<std::string, JobCard*> jobCards = m_dataStore.getJobCards();
 	util::Map<std::string, JobCard*> technicianJobCards;
-	for (int iterator = 0; iterator < trackedJobCards.getSize(); iterator++)
+	for (int iterator = 0; iterator < jobCards.getSize(); iterator++)
 	{
-		JobCard* currentJobCard = trackedJobCards.getValueAt(iterator).data;
+		JobCard* currentJobCard = jobCards.getValueAt(iterator);
 		if (currentJobCard->getTechnicianId() == technicianID)
 		{
 			technicianJobCards.insert(currentJobCard->getId(), currentJobCard);
@@ -977,68 +797,53 @@ Returns:
 */
 void ServiceManagementService::updateJobStatus(const std::string& jobID)
 {
-    AuthenticationManagementService::ensureAuthorization();
-    DataStoreLockGuard lock(m_dataStore);
-    AuthenticationManagementService authenticationManagementService;
-    PaymentManagementService paymentManagementService;
-    bool jobStatusUpdated = false, serviceBookingCompleted;
-    User* currentTechnician = authenticationManagementService.getAuthenticatedUser();
-    if (currentTechnician == nullptr)
-    {
-        throw std::runtime_error("Unable to fetch current technician.");
-    }
-    util::Map<std::string, JobCard*> currentAssignedJobs = getJobCards(currentTechnician->getId());
-    if (currentAssignedJobs.getSize() == 0)
-    {
-        throw std::runtime_error("No job cards assigned to the technician.");
-    }
-    auto& trackedJobCards = m_dataStore.getJobCards();
-    auto& trackedServiceBookings = m_dataStore.getServiceBookings();
-    if (currentAssignedJobs.find(jobID) != -1)
-    {
-        int jobIndex = trackedJobCards.find(jobID);
-        if (jobIndex == -1)
-        {
-            throw std::runtime_error("Unable to fetch current job.");
-        }
-        auto& trackedCurrentJob = trackedJobCards.getValueAt(jobIndex);
-        JobCard* currentJob = trackedCurrentJob.data;
-        if (currentJob == nullptr)
-        {
-            throw std::runtime_error("Unable to fetch current job.");
-        }
-        if (currentJob->getStatus() == util::ServiceJobStatus::STARTED)
-        {
-            currentJob->setStatus(util::ServiceJobStatus::IN_PROGRESS);
-            trackedCurrentJob.state = RecordState::MODIFIED;
-            jobStatusUpdated = true;
-        }
+	AuthenticationManagementService authenticationManagementService;
+	PaymentManagementService paymentManagementService;
+	bool jobStatusUpdated = false, serviceBookingCompleted;
+	JobCard* currentJob;
+	User* currentTechnician = authenticationManagementService.getAuthenticatedUser();
+	if (currentTechnician == nullptr)
+	{
+		throw std::runtime_error("Unable to fetch current technician.");
+	}
+	util::Map<std::string, JobCard*> currentAssignedJobs = getJobCards(currentTechnician->getId());
+	if (currentAssignedJobs.getSize() == 0)
+	{
+		throw std::runtime_error("No job cards assigned to the technician.");
+	}
+	if (currentAssignedJobs.find(jobID) != -1)
+	{
+		currentJob = currentAssignedJobs.getValueAt(currentAssignedJobs.find(jobID));
+		if (currentJob == nullptr)
+		{
+			throw std::runtime_error("Unable to fetch current job.");
+		}
+		if (currentJob->getStatus() == util::ServiceJobStatus::STARTED)
+		{
+			currentJob->setStatus(util::ServiceJobStatus::IN_PROGRESS);
+			jobStatusUpdated = true;
+		}
        else if (currentJob->getStatus() == util::ServiceJobStatus::IN_PROGRESS)
        {
            currentJob->setStatus(util::ServiceJobStatus::COMPLETED);
-            trackedCurrentJob.state = RecordState::MODIFIED;
            jobStatusUpdated = true;
            serviceBookingCompleted = hasCompletedAllJobs(currentJob->getBookingId(), currentAssignedJobs);
            if (serviceBookingCompleted)
            {
-                const std::string& bookingId = currentJob->getBookingId();
                currentJob->getBooking()->setStatus(util::ServiceJobStatus::COMPLETED);
-                trackedServiceBookings.getValueAt(trackedServiceBookings.find(bookingId)).state = RecordState::MODIFIED;
                paymentManagementService.generateInvoice(currentJob->getBooking());
                std::string title = "Service Booking completed. Invoice Generated.";
                std::string message = "Services completed for the booking and invoice generated.";
                sendNotification(currentJob->getBooking()->getCustomer(), title, message);
            }
        }
-    }
-    else
-    {
-        throw std::runtime_error("Failed to update job status. Job may already be completed.");
-    }
-    if (!jobStatusUpdated)
-    {
-        throw std::runtime_error("Failed to update job status. Job may already be completed.");
-    }
-    m_dataStore.saveJobCards();
-    m_dataStore.saveServiceBookings();
+	}
+	else
+	{
+		throw std::runtime_error("Failed to update job status. Job may already be completed.");
+	}
+	if (!jobStatusUpdated)
+	{
+		throw std::runtime_error("Failed to update job status. Job may already be completed.");
+	}
 }
@@ -35,7 +35,6 @@ 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);
@@ -15,7 +15,6 @@ Date:19-May-2026
 #include "Notification.h"
 #include "PaymentManagementService.h"
 #include "ServiceManagementService.h"
-#include "AuthenticationManagementService.h"
 #include "User.h"
 #include "UserManagementService.h"
 #include "Vector.h"
@@ -23,7 +22,6 @@ Date:19-May-2026
 #include "Utility.h"
 #include "TrackedRecord.h"
 #include "DataStoreLockGuard.h"
-#include "EventManager.h"

 /*
 Function: ensureAdminExists
@@ -115,7 +113,6 @@ Return type: void
 */
 void UserManagementService::updateUserDetails(const std::string& userID, const std::string& email, const std::string& phone)
 {
-    AuthenticationManagementService::ensureAuthorization();
 	DataStoreLockGuard lock(m_dataStore);
 	auto& trackedUsersMap = m_dataStore.getUsers();
 	auto usersMap = util::getObjects(trackedUsersMap);
@@ -163,7 +160,6 @@ Throws:
 */
 util::Vector<Notification*> UserManagementService::getUserNotifications(const std::string& userID)
 {
-    AuthenticationManagementService::ensureAuthorization();
 	DataStoreLockGuard lock(m_dataStore);
 	auto& trackedUsersMap = m_dataStore.getUsers(); 
 	if (trackedUsersMap.find(userID) == -1)
@@ -184,6 +180,7 @@ util::Vector<Notification*> UserManagementService::getUserNotifications(const st
 				notificationsVector.push_back(notification);
 			}
 		}
+		m_dataStore.unlockDataStore();
 		return notificationsVector;
 	}
 	else
@@ -207,7 +204,6 @@ Throws:
 */
 void UserManagementService::deleteNotification(const std::string& notificationID, const std::string& userID)
 {
-    AuthenticationManagementService::ensureAuthorization();
 	DataStoreLockGuard lock(m_dataStore);
 	auto& trackedUsersMap = m_dataStore.getUsers();
 	auto& trackedNotificationsMap = m_dataStore.getNotifications();
@@ -269,42 +265,33 @@ Return type: void
 */
 void UserManagementService::removeUser(const std::string& userID)
 {
-    AuthenticationManagementService::ensureAuthorization();
 	InventoryManagementService inventoryManagementService;
 	PaymentManagementService paymentManagementService;
 	ServiceManagementService serviceManagementService;
-	std::string removedUserID;
+	DataStoreLockGuard lock(m_dataStore);
+	auto& trackedUsersMap = m_dataStore.getUsers();
+	int index = trackedUsersMap.find(userID);
+	if (index != -1)
 	{
-		DataStoreLockGuard lock(m_dataStore);
-		auto& trackedUsersMap = m_dataStore.getUsers();
-		int index = trackedUsersMap.find(userID);
-		if (index != -1)
+		User* user = trackedUsersMap.getValueAt(index).data;
+		if (user != nullptr)
 		{
-			User* user = trackedUsersMap.getValueAt(index).data;
-			if (user != nullptr)
+			if (user->getUserType() == util::UserType::CUSTOMER)
 			{
-				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();
+				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;
+			m_dataStore.saveUsers();
 		}
 	}
-	if (!removedUserID.empty())
-	{
-		EventManager::sendUserDisabledEvent(removedUserID);
-	}
 }

 /*
@@ -30,16 +30,10 @@ Return type: void
 */
 void AdminMenu::showMenu()
 {
-	startEventListener();
    while (true)
    {
        try
        {
-			if (!m_isMenuActive)
-			{
-				logout();
-				break;
-			}
            int choice;
            util::clear();
            std::cout << "Admin Menu"
@@ -74,7 +68,6 @@ void AdminMenu::showMenu()
            util::pressEnter();
        }
    }
-	stopEventListener();
 }

 /*
@@ -85,11 +78,6 @@ 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:
@@ -153,25 +141,6 @@ 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.
@@ -338,23 +307,6 @@ 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,13 +9,12 @@ Date:19-May-2026

 #pragma once
 #include "Controller.h"
-#include "Menu.h"

-class AdminMenu : public Menu
+class AdminMenu
 {
 private:
+    Controller m_controller;
    bool handleOperation(int choice);
-    void handleNotificationEvent() override;
 public:
    void showMenu();
    void logout();
@@ -32,17 +32,10 @@ Return type: void
 */
 void CustomerMenu::showMenu()
 {
-
-    startEventListener();
    while (true)
    {
        try
        {
-            if (!m_isMenuActive)
-            {
-                logout();
-                break;
-            }
            int choice;
            util::clear();
            std::cout << "Customer Menu"
@@ -51,12 +44,11 @@ void CustomerMenu::showMenu()
                << "\n3. Update Profile"
                << "\n4. Change Password"
                << "\n5. View Service History"
-                << "\n6. Cancel Service Booking"
-                << "\n7. Complete Payments"
-                << "\n8. View Invoices"
-                << "\n9. View Notifications"
-                << "\n10. Configure Notifications"
-                << "\n11. Logout"
+                << "\n6. Complete Payments"
+                << "\n7. View Invoices"
+                << "\n8. View Notifications"
+                << "\n9. Configure Notifications"
+                << "\n10. Logout"
                << "\nEnter a choice: ";
            util::read(choice);
            if (!handleOperation(choice))
@@ -70,7 +62,6 @@ void CustomerMenu::showMenu()
            util::pressEnter();
        }
    }
-    stopEventListener();
 }

 /*
@@ -81,11 +72,6 @@ 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:
@@ -104,21 +90,18 @@ bool CustomerMenu::handleOperation(int choice)
        viewServiceHistory();
        break;
    case 6:
-        cancelServiceBooking();
-        break;
-    case 7:
        completePayments();
        break;
-    case 8:
+    case 7:
        viewInvoices();
        break;
-    case 9:
+    case 8:
        viewNotifications();
        break;
-    case 10:
+    case 9:
        configureNotifications();
        break;
-    case 11:
+    case 10:
        logout();
        return false;
    default:
@@ -128,25 +111,6 @@ 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.
@@ -220,13 +184,6 @@ 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)
@@ -269,13 +226,6 @@ 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)
    {
@@ -351,46 +301,6 @@ 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,14 +9,13 @@ Date:19-May-2026
 */

 #pragma once
-#include "Menu.h"
 #include "Controller.h"

-class CustomerMenu : public Menu
+class CustomerMenu
 {
 private:
+    Controller m_controller;
    bool handleOperation(int choice);
-    void handleNotificationEvent();
 public:
    void showMenu();
    void logout();
@@ -28,6 +27,5 @@ public:
    void completePayments();
    void viewInvoices();
    void viewNotifications();
-    void cancelServiceBooking();
    void configureNotifications();
 };
@@ -1,150 +0,0 @@
-/*
-File: Menu.cpp
-Description: Implementation file containing common menu event listener
-             functionality, account disable handling, and notification
-             event dispatching for all menu types.
-Author: Trenser
-Date:16-Jun-2026
-*/
-
-#include "Menu.h"
-
-/*
-Function: Menu
-Description: Constructs a Menu object and initializes event handles
-             and menu state.
-Parameter: None
-Return type: None
-*/
-Menu::Menu()
-    :
-    m_isMenuActive(false),
-    m_accountDisabledEvent(NULL),
-    m_notificationAvailableEvent(NULL),
-    m_shutdownEvent(NULL) {}
-
-/*
-Function: ~Menu
-Description: Destroys the Menu object and performs event listener
-             cleanup.
-Parameter: None
-Return type: None
-*/
-Menu::~Menu()
-{
-    stopEventListener();
-}
-
-/*
-Function: startEventListener
-Description: Creates menu event handles, registers them with the
-             authentication service, and starts the event listener
-             thread.
-Parameter: None
-Return type: void
-*/
-void Menu::startEventListener()
-{
-    if (m_isMenuActive.load())
-    {
-        return;
-    }
-    m_isMenuActive.store(true);
-    m_accountDisabledEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
-    m_notificationAvailableEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
-    m_shutdownEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
-    m_controller.registerEvents(m_accountDisabledEvent, m_notificationAvailableEvent);
-    m_eventListenerThread = std::thread(&Menu::eventListenerLoop, this);
-}
-
-/*
-Function: eventListenerLoop
-Description: Waits for account disabled, notification available,
-             and shutdown events and dispatches them to the
-             appropriate handlers.
-Parameter: None
-Return type: void
-*/
-void Menu::eventListenerLoop()
-{
-    HANDLE handles[3];
-    handles[0] = m_accountDisabledEvent;
-    handles[1] = m_notificationAvailableEvent;
-    handles[2] = m_shutdownEvent;
-    while (m_isMenuActive.load())
-    {
-        DWORD result = WaitForMultipleObjects(3, handles, FALSE, INFINITE);
-        switch (result)
-        {
-        case WAIT_OBJECT_0:
-            handleAccountDisabledEvent();
-            break;
-        case WAIT_OBJECT_0 + 1:
-            handleNotificationEvent();
-            break;
-        case WAIT_OBJECT_0 + 2:
-            return;
-        }
-    }
-}
-
-/*
-Function: stopEventListener
-Description: Stops the event listener thread and releases all
-             associated event handles.
-Parameter: None
-Return type: void
-*/
-void Menu::stopEventListener()
-{
-    m_isMenuActive.store(false);
-    if (m_shutdownEvent)
-    {
-        SetEvent(m_shutdownEvent);
-    }
-    if (m_eventListenerThread.joinable())
-    {
-        m_eventListenerThread.join();
-    }
-    if (m_accountDisabledEvent)
-    {
-        CloseHandle(m_accountDisabledEvent);
-    }
-    if (m_notificationAvailableEvent)
-    {
-        CloseHandle(m_notificationAvailableEvent);
-    }
-    if (m_shutdownEvent)
-    {
-        CloseHandle(m_shutdownEvent);
-    }
-    m_accountDisabledEvent = NULL;
-    m_notificationAvailableEvent = NULL;
-    m_shutdownEvent = NULL;
-}
-
-/*
-Function: handleAccountDisabledEvent
-Description: Handles an account disabled event by marking the menu
-             inactive and notifying the user.
-Parameter: None
-Return type: void
-*/
-void Menu::handleAccountDisabledEvent()
-{
-    m_isMenuActive.store(false);
-    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);
-}
@@ -1,33 +0,0 @@
-/*
-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,7 +28,6 @@ Date: 21-May-2026
 #include "Utility.h"
 #include "Validator.h"
 #include "Vector.h"
-#include "StringHelper.h"

 /*
 Function: displayAllServices
@@ -1057,21 +1056,6 @@ 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
@@ -1424,88 +1408,3 @@ inline std::string selectComboPackage(util::Map<std::string, const ComboPackage*
        return "";
    }
 }
-
-/*
-Function: displayNewNotification
-Description: Displays the most recent notification from the supplied
-             notification collection.
-Parameter: util::Vector<const Notification*> notifications -
-           collection of notifications
-           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,16 +27,10 @@ Returns:
 */
 void TechnicianMenu::showMenu()
 {
-    startEventListener();
    while (true)
    {
        try
        {
-            if (!m_isMenuActive)
-            {
-                logout();
-                break;
-            }
            int choice;
            util::clear();
            std::cout << "Technician Menu"
@@ -58,7 +52,6 @@ void TechnicianMenu::showMenu()
            util::pressEnter();
        }
    }
-    stopEventListener();
 }

 /*
@@ -69,11 +62,6 @@ 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:
@@ -98,25 +86,6 @@ 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,13 +9,12 @@ Date:19-May-2026

 #pragma once
 #include "Controller.h"
-#include "Menu.h"

-class TechnicianMenu : public Menu
+class TechnicianMenu
 {
 private:
+    Controller m_controller;
    bool handleOperation(int choice);
-    void handleNotificationEvent();
 public:
    void showMenu();
    void displayJobs();
Author	SHA1	Message	Date
joelthomastrenser	6450f8e62f	Fix cache refresh handling for unsaved records - Preserve NEW_RECORD entries during cache refresh - Prevent accidental deletion of pending datastore changes - Clean up only stale persisted records	2026-06-14 17:00:49 +05:30
joelthomastrenser	6971663d33	Clean up legacy code - Remove FileManager and related file-based persistence logic - Remove obsolete observer persistence utilities - Remove unused service APIs and includes - Delete duplicate DataStore mutex stubs - Perform general dead-code cleanup	2026-06-14 15:59:39 +05:30
joelthomastrenser	edd0c60e40	Implement Service Refactoring <UserStory> 1954: Implement Service Refactoring </UserStory> UserStory #1954 <Changes> 1. Refactored notification handling to persist notifications directly in the datastore instead of maintaining notification collections within User objects. 2. Removed recipient User pointer dependencies from Notification and retained recipient user identification through recipientUserId. 3. Implemented generic observer persistence support in DataStore with shared helper methods for loading and saving observer subscriptions. 4. Added datastore-backed observer management for ServiceManagementService, PaymentManagementService, and InventoryManagementService. 5. Updated attach() and detach() operations to load, modify, and persist observer subscriptions using shared memory mappings. 6. Refactored sendNotification() implementations to create and persist Notification records directly to the datastore for subscribed observers. 7. Updated UserManagementService notification retrieval and deletion logic to operate on datastore notification records filtered by recipient user ID. 8. Removed notification ownership and observer-specific notification APIs from User and Observer classes. 9. Added configurable shared memory growth factor support and updated mapping expansion logic to use centralized configuration values. 10. Removed obsolete NotificationManagementService implementation and updated project configuration references. 11. Added DataStoreLockGuard integration for observer and notification persistence operations to ensure synchronized datastore access. </Changes> <Test> N/A </Test> <Review> Sreeja Reghukumar, please review </Review>	2026-06-12 19:25:27 +05:30
joelthomastrenser	79d6b47aa8	Implement Notification Model Refactoring <UserStory> 1953: Model Refactoring </UserStory> UserStory #1953 <Changes> 1. Replaced CSV-based Notification serialization and deserialization with SerializedNotification record-based serialization for shared memory storage. 2. Implemented Notification::serialize() to convert Notification objects into fixed-size SerializedNotification structures. 3. Implemented Notification::deserialize() to reconstruct Notification objects directly from SerializedNotification records. 4. Added Notification state persistence by introducing util::State support in constructors, serialization, and deserialization flows. 5. Updated Notification class interfaces to use SerializedNotification types instead of std::string serialization APIs. 6. Removed legacy CSV serialization support, including CSV parsing logic and header generation functionality. 7. Added SerializedNotification dependencies through SerializedRecords.h inclusion and forward declaration support. 8. Initialized Notification objects with ACTIVE state by default and added state getter/setter APIs. </Changes> <Test> N/A </Test> <Review> Sreeja Reghukumar, please review </Review>	2026-06-12 17:36:15 +05:30