Implement Model Refactoring

<UserStory> 1955: Model Refactoring</UserStory>

UserStory #1955

<Changes>
1. Replaced CSV-based serialization and deserialization in ComboPackage, JobCard, Service, and ServiceBooking models with fixed-size SerializedRecord structures for shared memory storage.
2. Implemented serialize() methods to convert objects into SerializedComboPackage, SerializedJobCard, SerializedService, and SerializedServiceBooking records.
3. Implemented deserialize() methods to reconstruct objects directly from SerializedRecord types instead of parsing CSV strings.
4. Updated model class interfaces to use SerializedRecord types, removing legacy CSV serialization APIs and header generation functions.
5. Added SerializedRecords.h dependencies and forward declarations for Serialized structures across affected models.
</Changes>

<Test>
N/A
</Test>

<Review>
Sreeja Reghukumar, please review
</Review>

.gitignore

@@ -427,5 +427,5 @@ FodyWeavers.xsd
 *.msm
 *.msp
 
-# DAT Files
-*.dat
+# CSV Files
+*.csv

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

@@ -102,7 +102,7 @@
       <SDLCheck>true</SDLCheck>
       <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
-      <AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)factories;$(ProjectDir)views;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)core\patterns;$(ProjectDir)datastores;$(ProjectDir)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" />
@@ -141,6 +140,7 @@
     <ClCompile Include="models\User.cpp" />
     <ClCompile Include="services\AuthenticationManagementService.cpp" />
     <ClCompile Include="services\InventoryManagementService.cpp" />
+    <ClCompile Include="services\NotificationManagementService.cpp" />
     <ClCompile Include="services\PaymentManagementService.cpp" />
     <ClCompile Include="services\ServiceManagementService.cpp" />
     <ClCompile Include="services\UserManagementService.cpp" />
@@ -149,23 +149,20 @@
     <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" />
@@ -184,6 +181,7 @@
     <ClInclude Include="utilities\Config.h" />
     <ClInclude Include="utilities\Enums.h" />
     <ClInclude Include="utilities\FileHelper.h" />
+    <ClInclude Include="utilities\FileManager.h" />
     <ClInclude Include="utilities\InputHelper.h" />
     <ClInclude Include="utilities\Map.h" />
     <ClInclude Include="utilities\OutputHelper.h" />
@@ -194,7 +192,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" />

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

@@ -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>
@@ -120,6 +114,9 @@
     <ClCompile Include="datastores\DataStore.cpp">
       <Filter>Source Files\DataStores</Filter>
     </ClCompile>
+    <ClCompile Include="services\NotificationManagementService.cpp">
+      <Filter>Source Files\Services</Filter>
+    </ClCompile>
     <ClCompile Include="core\patterns\Observer.cpp">
       <Filter>Source Files\Core\Patterns</Filter>
     </ClCompile>
@@ -150,14 +147,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>
@@ -254,6 +245,9 @@
     <ClInclude Include="utilities\Config.h">
       <Filter>Header Files\Utilities</Filter>
     </ClInclude>
+    <ClInclude Include="utilities\FileManager.h">
+      <Filter>Header Files\Utilities</Filter>
+    </ClInclude>
     <ClInclude Include="utilities\StringHelper.h">
       <Filter>Header Files\Utilities</Filter>
     </ClInclude>
@@ -266,32 +260,23 @@
     <ClInclude Include="views\MenuHelper.h">
       <Filter>Header Files\Views</Filter>
     </ClInclude>
-    <ClInclude Include="datastores\DataStoreLockGuard.h">
-      <Filter>Header Files\DataStores</Filter>
+    <ClInclude Include="datastores\sharedmemory\FileHeader.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
     </ClInclude>
-    <ClInclude Include="core\sharedmemory\FileHeader.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
+    <ClInclude Include="datastores\sharedmemory\MappingInfo.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
     </ClInclude>
-    <ClInclude Include="core\sharedmemory\MappingInfo.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
+    <ClInclude Include="datastores\sharedmemory\RecordState.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
     </ClInclude>
-    <ClInclude Include="core\sharedmemory\RecordState.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
+    <ClInclude Include="datastores\sharedmemory\TrackedRecord.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
     </ClInclude>
-    <ClInclude Include="core\sharedmemory\SerializedRecords.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
+    <ClInclude Include="datastores\sharedmemory\SerializedRecords.h">
+      <Filter>Header Files\DataStores\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 Include="datastores\sharedmemory\SharedMemory.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
     </ClInclude>
   </ItemGroup>
 </Project>

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

@@ -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.
@@ -600,50 +588,63 @@ void Controller::configureNotifications(bool paymentNotifications, bool serviceN
 }
 
 /*
-Function: initialize
-Description: Initializes the system and run system checks to ensure critical configurations, such as verifying admin existence.
-Parameters:
-    - None
-Returns:
-    - bool
-*/
-bool Controller::initialize()
-{
-    auto& dataStore = DataStore::getInstance();
-
-    if (!dataStore.initialize())
-    {
-        return false;
-    }
-    m_userManagementService.ensureAdminExists();
-    m_inventoryManagementService.sendLowStockAlerts();
-    m_paymentManagementService.sendPaymentReminders();
-    return true;
-}
-
-/*
-Function: shutdown
-Description: Shutdown the system, and do necessary cleanups
+Function: loadSystemData
+Description: Loads all system data from persistent storage into memory.
+             Invokes the respective management services to load users, inventory items, services,
+             combo packages, service bookings, job cards, invoices, and observers.
 Parameters:
     - None
 Returns:
     - void
 */
-void Controller::shutdown()
+void Controller::loadSystemData()
 {
-    auto& dataStore = DataStore::getInstance();
-    dataStore.shutdown();
+    m_userManagementService.loadUsers();
+    m_inventoryManagementService.loadInventoryItems();
+    m_serviceManagementService.loadServices();
+    m_serviceManagementService.loadComboPackages();
+    m_serviceManagementService.loadServiceBookings();
+    m_serviceManagementService.loadJobCards();
+    m_paymentManagementService.loadInvoices();
+    m_serviceManagementService.loadObservers();
+    m_paymentManagementService.loadObservers();
+    m_inventoryManagementService.loadObservers();
 }
 
 /*
-Function: registerEvents
-Description: Registers menu event handles with the authentication
-             service.
-Parameter: HANDLE accountDisabledEvent - account disabled event handle
-           HANDLE notificationAvailableEvent - notification event handle
+Function: saveSystemData
+Description: Saves all system data from memory back to persistent storage.
+             Invokes the respective management services to save users, inventory items, services,
+             combo packages, service bookings, job cards, invoices, and observers.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void Controller::saveSystemData()
+{
+    m_userManagementService.saveUsers();
+    m_inventoryManagementService.saveInventoryItems();
+    m_serviceManagementService.saveServices();
+    m_serviceManagementService.saveComboPackages();
+    m_serviceManagementService.saveServiceBookings();
+    m_serviceManagementService.saveJobCards();
+    m_paymentManagementService.saveInvoices();
+    m_serviceManagementService.saveObservers();
+    m_paymentManagementService.saveObservers();
+    m_inventoryManagementService.saveObservers();
+}
+
+/*
+Function: runSystemChecks
+Description: Runs system checks to ensure critical configurations, such as verifying admin existence.
+Parameter: None
 Return type: void
 */
-void Controller::registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent)
+void Controller::runSystemChecks()
 {
-    m_authenticationManagementService.registerEvents(accountDisabledEvent, notificationAvailableEvent);
+    m_userManagementService.ensureAdminExists();
+    m_inventoryManagementService.sendLowStockAlerts();
+    m_paymentManagementService.sendPaymentReminders();
 }
+

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

@@ -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);
@@ -72,7 +70,7 @@ public:
     util::Vector<const Notification*> getNotifications();
     void deleteNotification(const std::string& notificationID);
     void configureNotifications(bool paymentNotifications, bool serviceNotifications);
-    bool initialize();
-    void shutdown();
-    void registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent);
+    void loadSystemData();
+    void saveSystemData();
+    void runSystemChecks();
 };

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

@@ -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);
-}

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

@@ -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);
-};

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/core/patterns/Observer.h

@@ -7,8 +7,11 @@ Date: 19-May-2026
 
 #pragma once
 
+class Notification;
+
 class Observer
 {
 public:
     virtual ~Observer() = default;
+    virtual void addNotification(Notification* notification) = 0;
 };

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

@@ -12,46 +12,10 @@ Date: 19-May-2026
 #include "Config.h"
 #include "SerializedRecords.h"
 #include "FileHelper.h"
-#include "ServiceBooking.h"
-#include "JobCard.h"
-#include "Invoice.h"
 
-/*
-Function: DataStore
-Description: Constructs the DataStore singleton and initializes
-             internal handles to their default values.
-Parameters:
-    - None
-Returns:
-    - None
-*/
 DataStore::DataStore() :
     m_globalMutex(NULL) {}
 
-/*
-Function: ~DataStore
-Description: Destroys the DataStore singleton and releases all
-             cached application objects owned by the datastore.
-             This includes users, notifications, services,
-             combo packages, inventory items, service bookings,
-             job cards, and invoices.
-Parameters:
-    - None
-Returns:
-    - None
-*/
-DataStore::~DataStore()
-{
-    clearCache(m_userCache);
-    clearCache(m_notificationCache);
-    clearCache(m_serviceCache);
-    clearCache(m_comboPackageCache);
-    clearCache(m_inventoryItemCache);
-    clearCache(m_serviceBookingCache);
-    clearCache(m_jobCardCache);
-    clearCache(m_invoiceCache);
-}
-
 /*
 Function: initialize
 Description: Initializes the shared-memory datastore.
@@ -147,6 +111,11 @@ bool DataStore::initialize()
             success = false;
             break;
         }
+        if (!SharedMemory::createOrOpenMapping(m_payments))
+        {
+            success = false;
+            break;
+        }
         if (!SharedMemory::createOrOpenMapping(m_serviceManagementObservers))
         {
             success = false;
@@ -191,6 +160,7 @@ void DataStore::shutdown()
     SharedMemory::closeMapping(m_serviceBookings);
     SharedMemory::closeMapping(m_jobCards);
     SharedMemory::closeMapping(m_invoices);
+    SharedMemory::closeMapping(m_payments);
     SharedMemory::closeMapping(m_serviceManagementObservers);
     SharedMemory::closeMapping(m_paymentManagementObservers);
     SharedMemory::closeMapping(m_inventoryManagementObservers);
@@ -223,11 +193,9 @@ Parameters:
 Returns:
     - util::Map<std::string, TrackedRecord<User>>: Collection of user records
 */
-util::Map<std::string, TrackedRecord<User>>& DataStore::getUsers()
+util::Map<std::string, TrackedRecord<User>> DataStore::getUsers()
 {
-    auto users = loadRecords<User, SerializedUser>(m_users);
-    refreshCache(m_userCache, users);
-    return m_userCache;
+    return util::Map<std::string, TrackedRecord<User>>();
 }
 
 /*
@@ -238,11 +206,9 @@ Parameters:
 Returns:
     - util::Map<std::string, TrackedRecord<Notification>>: Collection of notification records
 */
-util::Map<std::string, TrackedRecord<Notification>>& DataStore::getNotifications()
+util::Map<std::string, TrackedRecord<Notification>> DataStore::getNotifications()
 {
-    auto notifications = loadRecords<Notification, SerializedNotification>(m_notifications);
-    refreshCache(m_notificationCache, notifications);
-    return m_notificationCache;
+    return util::Map<std::string, TrackedRecord<Notification>>();
 }
 
 /*
@@ -253,31 +219,9 @@ Parameters:
 Returns:
     - util::Map<std::string, TrackedRecord<Service>>: Collection of service records
 */
-util::Map<std::string, TrackedRecord<Service>>& DataStore::getServices()
+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;
+    return util::Map<std::string, TrackedRecord<Service>>();
 }
 
 /*
@@ -288,31 +232,9 @@ Parameters:
 Returns:
     - util::Map<std::string, TrackedRecord<ComboPackage>>: Collection of combo package records
 */
-util::Map<std::string, TrackedRecord<ComboPackage>>& DataStore::getComboPackages()
+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;
+    return util::Map<std::string, TrackedRecord<ComboPackage>>();
 }
 
 /*
@@ -323,11 +245,9 @@ Parameters:
 Returns:
     - util::Map<std::string, TrackedRecord<InventoryItem>>: Collection of inventory item records
 */
-util::Map<std::string, TrackedRecord<InventoryItem>>& DataStore::getInventoryItems()
+util::Map<std::string, TrackedRecord<InventoryItem>> DataStore::getInventoryItems()
 {
-    auto inventoryItems = loadRecords<InventoryItem, SerializedInventoryItem>(m_inventoryItems);
-    refreshCache(m_inventoryItemCache, inventoryItems);
-    return m_inventoryItemCache;
+    return util::Map<std::string, TrackedRecord<InventoryItem>>();
 }
 
 /*
@@ -338,52 +258,9 @@ Parameters:
 Returns:
     - util::Map<std::string, TrackedRecord<ServiceBooking>>: Collection of service booking records
 */
-util::Map<std::string, TrackedRecord<ServiceBooking>>& DataStore::getServiceBookings()
+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;
+    return util::Map<std::string, TrackedRecord<ServiceBooking>>();
 }
 
 /*
@@ -394,53 +271,11 @@ Parameters:
 Returns:
     - util::Map<std::string, TrackedRecord<JobCard>>: Collection of job card records
 */
-util::Map<std::string, TrackedRecord<JobCard>>& DataStore::getJobCards()
+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;
+    return util::Map<std::string, TrackedRecord<JobCard>>();
 }
 
-
 /*
 Function: getInvoices
 Description: Retrieves all invoice records from the datastore.
@@ -449,79 +284,22 @@ Parameters:
 Returns:
     - util::Map<std::string, TrackedRecord<Invoice>>: Collection of invoice records
 */
-util::Map<std::string, TrackedRecord<Invoice>>& DataStore::getInvoices()
+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;
+    return util::Map<std::string, TrackedRecord<Invoice>>();
 }
 
 /*
-Function: getObservers
-Description: Retrieves observer records from the specified observer mapping
-             and resolves them to User objects.
+Function: getPayments
+Description: Retrieves all payment records from the datastore.
 Parameters:
-    - mapping: Observer mapping to read from
+    - None
 Returns:
-    - util::Map<std::string, User*>: Collection of observer records
-Throws:
-    - std::runtime_error if an observer references an invalid user ID
+    - util::Map<std::string, TrackedRecord<Payment>>: Collection of payment records
 */
-util::Map<std::string, User*> DataStore::getObservers(MappingInfo& mapping)
+util::Map<std::string, TrackedRecord<Payment>> DataStore::getPayments()
 {
-    auto& users = getUsers();
-    util::Map<std::string, User*> observers;
-    SharedMemory::ensureLatestMapping(mapping);
-    size_t recordCount = SharedMemory::getRecordCount(mapping);
-    for (size_t index = 0; index < recordCount; index++)
-    {
-        const SerializedObserver* observer = static_cast<SerializedObserver*>(SharedMemory::getRecordAddress(mapping, index));
-        int userIndex = users.find(observer->id);
-        if (userIndex == -1)
-        {
-            throw std::runtime_error("Invalid observer user ID");
-        }
-        User* user = users.getValueAt(userIndex).data;
-        observers.insert(user->getId(), user);
-    }
-    return observers;
+    return util::Map<std::string, TrackedRecord<Payment>>();
 }
 
 /*
@@ -530,11 +308,11 @@ Description: Retrieves all service management observer records from the datastor
 Parameters:
     - None
 Returns:
-    - util::Map<std::string, User*>: Collection of observer records
+    - util::Map<std::string, TrackedRecord<std::string>>: Collection of observer records
 */
-util::Map<std::string, User*> DataStore::getServiceManagementObservers()
+util::Map<std::string, TrackedRecord<std::string>> DataStore::getServiceManagementObservers()
 {
-    return getObservers(m_serviceManagementObservers);
+    return util::Map<std::string, TrackedRecord<std::string>>();
 }
 
 /*
@@ -543,11 +321,11 @@ Description: Retrieves all payment management observer records from the datastor
 Parameters:
     - None
 Returns:
-    - util::Map<std::string, User*>: Collection of observer records
+    - util::Map<std::string, TrackedRecord<std::string>>: Collection of observer records
 */
-util::Map<std::string, User*> DataStore::getPaymentManagementObservers()
+util::Map<std::string, TrackedRecord<std::string>> DataStore::getPaymentManagementObservers()
 {
-    return getObservers(m_paymentManagementObservers);
+    return util::Map<std::string, TrackedRecord<std::string>>();
 }
 
 /*
@@ -556,186 +334,181 @@ Description: Retrieves all inventory management observer records from the datast
 Parameters:
     - None
 Returns:
-    - util::Map<std::string, User*>: Collection of observer records
+    - util::Map<std::string, TrackedRecord<std::string>>: Collection of observer records
 */
-util::Map<std::string, User*> DataStore::getInventoryManagementObservers()
+util::Map<std::string, TrackedRecord<std::string>> DataStore::getInventoryManagementObservers()
 {
-    return getObservers(m_inventoryManagementObservers);
+    return util::Map<std::string, TrackedRecord<std::string>>();
 }
 
 /*
 Function: saveUsers
 Description: Persists all user records to the datastore.
 Parameters:
-    - None
+    - users: util::Map<std::string, TrackedRecord<User>>&, collection of user records
 Returns:
     - None
 */
-void DataStore::saveUsers()
+void DataStore::saveUsers(util::Map<std::string, TrackedRecord<User>>& users)
 {
-    saveRecords<User, SerializedUser>(m_users, m_userCache);
 }
 
 /*
 Function: saveNotifications
 Description: Persists all notification records to the datastore.
 Parameters:
-    - None
+    - notifications: util::Map<std::string, TrackedRecord<Notification>>&, collection of notification records
 Returns:
     - None
 */
-void DataStore::saveNotifications()
+void DataStore::saveNotifications(util::Map<std::string, TrackedRecord<Notification>>& notifications)
 {
-    saveRecords<Notification, SerializedNotification>(m_notifications, m_notificationCache);
 }
 
 /*
 Function: saveServices
 Description: Persists all service records to the datastore.
 Parameters:
-    - None
+    - services: util::Map<std::string, TrackedRecord<Service>>&, collection of service records
 Returns:
     - None
 */
-void DataStore::saveServices()
+void DataStore::saveServices(util::Map<std::string, TrackedRecord<Service>>& services)
 {
-    saveRecords<Service, SerializedService>(m_services, m_serviceCache);
 }
 
 /*
 Function: saveComboPackages
 Description: Persists all combo package records to the datastore.
 Parameters:
-    - None
+    - comboPackages: util::Map<std::string, TrackedRecord<ComboPackage>>&, collection of combo package records
 Returns:
     - None
 */
-void DataStore::saveComboPackages()
+void DataStore::saveComboPackages(util::Map<std::string, TrackedRecord<ComboPackage>>& comboPackages)
 {
-    saveRecords<ComboPackage, SerializedComboPackage>(m_comboPackages, m_comboPackageCache);
 }
 
 /*
 Function: saveInventoryItems
 Description: Persists all inventory item records to the datastore.
 Parameters:
-    - None
+    - inventoryItems: util::Map<std::string, TrackedRecord<InventoryItem>>&, collection of inventory item records
 Returns:
     - None
 */
-void DataStore::saveInventoryItems()
+void DataStore::saveInventoryItems(util::Map<std::string, TrackedRecord<InventoryItem>>& inventoryItems)
 {
-    saveRecords<InventoryItem, SerializedInventoryItem>(m_inventoryItems, m_inventoryItemCache);
 }
 
 /*
 Function: saveServiceBookings
 Description: Persists all service booking records to the datastore.
 Parameters:
-    - None
+    - bookings: util::Map<std::string, TrackedRecord<ServiceBooking>>&, collection of service booking records
 Returns:
     - None
 */
-void DataStore::saveServiceBookings()
+void DataStore::saveServiceBookings(util::Map<std::string, TrackedRecord<ServiceBooking>>& bookings)
 {
-    saveRecords<ServiceBooking, SerializedServiceBooking>(m_serviceBookings, m_serviceBookingCache);
 }
 
 /*
 Function: saveJobCards
 Description: Persists all job card records to the datastore.
 Parameters:
-    - None
+    - jobCards: util::Map<std::string, TrackedRecord<JobCard>>&, collection of job card records
 Returns:
     - None
 */
-void DataStore::saveJobCards()
+void DataStore::saveJobCards(util::Map<std::string, TrackedRecord<JobCard>>& jobCards)
 {
-    saveRecords<JobCard, SerializedJobCard>(m_jobCards, m_jobCardCache);
 }
 
 /*
 Function: saveInvoices
 Description: Persists all invoice records to the datastore.
 Parameters:
-    - None
+    - invoices: util::Map<std::string, TrackedRecord<Invoice>>&, collection of invoice records
 Returns:
     - None
 */
-void DataStore::saveInvoices()
+void DataStore::saveInvoices(util::Map<std::string, TrackedRecord<Invoice>>& invoices)
 {
-    saveRecords<Invoice, SerializedInvoice>(m_invoices, m_invoiceCache);
 }
 
 /*
-Function: saveObservers
-Description: Persists observer records to the specified observer mapping.
+Function: savePayments
+Description: Persists all payment records to the datastore.
 Parameters:
-    - mapping: MappingInfo&, observer mapping to save to
-    - observers: util::Map<std::string, User*>&, collection of observer records
+    - payments: util::Map<std::string, TrackedRecord<Payment>>&, collection of payment records
 Returns:
     - None
 */
-void DataStore::saveObservers(MappingInfo& mapping, util::Map<std::string, User*>& observers)
+void DataStore::savePayments(util::Map<std::string, TrackedRecord<Payment>>& payments)
 {
-    size_t observerCount = static_cast<size_t>(observers.getSize());
-    size_t capacity = config::file::INITIAL_CAPACITY;
-    while (capacity < observerCount)
-    {
-        capacity *= config::file::GROWTH_FACTOR;
-    }
-    if (!SharedMemory::resizeMapping(mapping, capacity))
-    {
-        throw std::runtime_error("Failed to resize observer mapping");
-    }
-    SharedMemory::setRecordCount(mapping, observerCount);
-    for (size_t index = 0; index < observerCount; index++)
-    {
-        SerializedObserver serializedObserver{};
-        User* user = observers.getValueAt(static_cast<int>(index));
-        strcpy_s(serializedObserver.id, sizeof(serializedObserver.id), user->getId().c_str());
-        SerializedObserver* destination = static_cast<SerializedObserver*>(SharedMemory::getRecordAddress(mapping, index));
-        *destination = serializedObserver;
-    }
 }
 
 /*
 Function: saveServiceManagementObservers
 Description: Persists all service management observer records to the datastore.
 Parameters:
-    - observers: util::Map<std::string, User*>&, collection of observer records
+    - observers: util::Map<std::string, TrackedRecord<std::string>>&, collection of observer records
 Returns:
     - None
 */
-void DataStore::saveServiceManagementObservers(util::Map<std::string, User*>& observers)
+void DataStore::saveServiceManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers)
 {
-    saveObservers(m_serviceManagementObservers, observers);
 }
 
 /*
 Function: savePaymentManagementObservers
 Description: Persists all payment management observer records to the datastore.
 Parameters:
-    - observers: util::Map<std::string, User*>&, collection of observer records
+    - observers: util::Map<std::string, TrackedRecord<std::string>>&, collection of observer records
 Returns:
     - None
 */
-void DataStore::savePaymentManagementObservers(util::Map<std::string, User*>& observers)
+void DataStore::savePaymentManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers)
 {
-    saveObservers(m_paymentManagementObservers, observers);
 }
 
 /*
 Function: saveInventoryManagementObservers
 Description: Persists all inventory management observer records to the datastore.
 Parameters:
-    - observers: util::Map<std::string, User*>&, collection of observer records
+    - observers: util::Map<std::string, TrackedRecord<std::string>>&, collection of observer records
 Returns:
     - None
 */
-void DataStore::saveInventoryManagementObservers(util::Map<std::string, User*>& observers)
+void DataStore::saveInventoryManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers)
 {
-    saveObservers(m_inventoryManagementObservers, observers);
+}
+
+/*
+Function: lockDataStore
+Description: Acquires exclusive access to the datastore.
+Parameters:
+    - None
+Returns:
+    - bool: True if the datastore was successfully locked, otherwise false
+*/
+bool DataStore::lockDataStore()
+{
+    return false;
+}
+
+/*
+Function: unlockDataStore
+Description: Releases exclusive access to the datastore.
+Parameters:
+    - None
+Returns:
+    - bool: True if the datastore was successfully unlocked, otherwise false
+*/
+bool DataStore::unlockDataStore()
+{
+    return false;
 }
 
 /*

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

@@ -11,22 +11,21 @@ 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"
-#include "Service.h"
-#include "ComboPackage.h"
-#include "InventoryItem.h"
-#include "ServiceBooking.h"
-#include "JobCard.h"
-#include "Invoice.h"
+class User;
+class Notification;
+class Service;
+class ComboPackage;
+class InventoryItem;
+class ServiceBooking;
+class JobCard;
+class Invoice;
+class Payment;
 
 class DataStore
 {
 private:
     DataStore();
-    ~DataStore();
     DataStore(const DataStore&) = delete;
     DataStore& operator=(const DataStore&) = delete;
     DataStore(DataStore&&) = delete;
@@ -40,43 +39,38 @@ private:
     MappingInfo m_serviceBookings;
     MappingInfo m_jobCards;
     MappingInfo m_invoices;
+    MappingInfo m_payments;
     MappingInfo m_serviceManagementObservers;
     MappingInfo m_paymentManagementObservers;
     MappingInfo m_inventoryManagementObservers;
-    util::Map<std::string, TrackedRecord<User>> m_userCache;
-    util::Map<std::string, TrackedRecord<Notification>> m_notificationCache;
-    util::Map<std::string, TrackedRecord<Service>> m_serviceCache;
-    util::Map<std::string, TrackedRecord<ComboPackage>> m_comboPackageCache;
-    util::Map<std::string, TrackedRecord<InventoryItem>> m_inventoryItemCache;
-    util::Map<std::string, TrackedRecord<ServiceBooking>> m_serviceBookingCache;
-    util::Map<std::string, TrackedRecord<JobCard>> m_jobCardCache;
-    util::Map<std::string, TrackedRecord<Invoice>> m_invoiceCache;
 public:
     static DataStore& getInstance();
     bool initialize();
     void shutdown();
-    util::Map<std::string, TrackedRecord<User>>& getUsers();
-    util::Map<std::string, TrackedRecord<Notification>>& getNotifications();
-    util::Map<std::string, TrackedRecord<Service>>& getServices();
-    util::Map<std::string, TrackedRecord<ComboPackage>>& getComboPackages();
-    util::Map<std::string, TrackedRecord<InventoryItem>>& getInventoryItems();
-    util::Map<std::string, TrackedRecord<ServiceBooking>>& getServiceBookings();
-    util::Map<std::string, TrackedRecord<JobCard>>& getJobCards();
-    util::Map<std::string, TrackedRecord<Invoice>>& getInvoices();
-    util::Map<std::string, User*> getServiceManagementObservers();
-    util::Map<std::string, User*> getPaymentManagementObservers();
-    util::Map<std::string, User*> getInventoryManagementObservers();
-    void saveUsers();
-    void saveNotifications();
-    void saveServices();
-    void saveComboPackages();
-    void saveInventoryItems();
-    void saveServiceBookings();
-    void saveJobCards();
-    void saveInvoices();
-    void saveServiceManagementObservers(util::Map<std::string, User*>& observers);
-    void savePaymentManagementObservers(util::Map<std::string, User*>& observers);
-    void saveInventoryManagementObservers(util::Map<std::string, User*>& observers);
+    util::Map<std::string, TrackedRecord<User>> getUsers();
+    util::Map<std::string, TrackedRecord<Notification>> getNotifications();
+    util::Map<std::string, TrackedRecord<Service>> getServices();
+    util::Map<std::string, TrackedRecord<ComboPackage>> getComboPackages();
+    util::Map<std::string, TrackedRecord<InventoryItem>> getInventoryItems();
+    util::Map<std::string, TrackedRecord<ServiceBooking>> getServiceBookings();
+    util::Map<std::string, TrackedRecord<JobCard>> getJobCards();
+    util::Map<std::string, TrackedRecord<Invoice>> getInvoices();
+    util::Map<std::string, TrackedRecord<Payment>> getPayments();
+    util::Map<std::string, TrackedRecord<std::string>> getServiceManagementObservers();
+    util::Map<std::string, TrackedRecord<std::string>> getPaymentManagementObservers();
+    util::Map<std::string, TrackedRecord<std::string>> getInventoryManagementObservers();
+    void saveUsers(util::Map<std::string, TrackedRecord<User>>& users);
+    void saveNotifications(util::Map<std::string, TrackedRecord<Notification>>& notifications);
+    void saveServices(util::Map<std::string, TrackedRecord<Service>>& services);
+    void saveComboPackages(util::Map<std::string, TrackedRecord<ComboPackage>>& comboPackages);
+    void saveInventoryItems(util::Map<std::string, TrackedRecord<InventoryItem>>& inventoryItems);
+    void saveServiceBookings(util::Map<std::string, TrackedRecord<ServiceBooking>>& bookings);
+    void saveJobCards(util::Map<std::string, TrackedRecord<JobCard>>& jobCards);
+    void saveInvoices(util::Map<std::string, TrackedRecord<Invoice>>& invoices);
+    void savePayments(util::Map<std::string, TrackedRecord<Payment>>& payments);
+    void saveServiceManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers);
+    void savePaymentManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers);
+    void saveInventoryManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers);
     bool lockDataStore();
     bool unlockDataStore();
 private:
@@ -84,10 +78,6 @@ private:
     util::Map<std::string, TrackedRecord<TObject>> loadRecords(MappingInfo& mapping);
     template<typename TObject, typename TSerialized>
     void saveRecords(MappingInfo& mapping, util::Map<std::string, TrackedRecord<TObject>>& records);
-    template<typename TObject> void clearCache(util::Map<std::string, TrackedRecord<TObject>>&cache);
-    template<typename TObject> void refreshCache(util::Map<std::string, TrackedRecord<TObject>>&cache, util::Map<std::string, TrackedRecord<TObject>>&refreshedCache);
-    util::Map<std::string, User*> getObservers(MappingInfo& mapping);
-    void saveObservers(MappingInfo& mapping, util::Map<std::string, User*>& observers);
 };
 
 /*
@@ -133,7 +123,9 @@ Description: Persists all modified and newly added records
              shared-memory mapping. Modified records overwrite
              their existing slots, while new records are
              appended to the end of the mapping. Records marked
-             as CLEAN are ignored.
+             as CLEAN are ignored. After persistence, all
+             temporary objects owned by the tracked records are
+             destroyed to release memory.
 Parameter:
     - mapping: Reference to the mapping where records are
                stored.
@@ -166,88 +158,14 @@ template<typename TObject, typename TSerialized> void DataStore::saveRecords(Map
                 continue;
             }
             size_t recordCount = SharedMemory::getRecordCount(mapping);
-            TSerialized* destination = static_cast<TSerialized*>(SharedMemory::getRecordAddress(mapping,recordCount));
+            TSerialized* destination = static_cast<TSerialized*>(SharedMemory::getRecordAddress(mapping, recordCount));
             *destination = serialized;
             SharedMemory::setRecordCount(mapping, recordCount + 1);
-            record.slotIndex = recordCount;
         }
-        record.state = RecordState::CLEAN;
     }
-}
-
-/*
-Function: clearCache
-Description: Releases all objects owned by the cache and
-             clears the cache contents.
-Parameters:
-    - cache: Cache to be cleared.
-Returns:
-    - None
-*/
-template<typename TObject>
-void DataStore::clearCache(util::Map<std::string, TrackedRecord<TObject>>&cache)
-{
-    for (int index = 0; index < cache.getSize(); ++index)
+    for (int index = 0; index < records.getSize(); ++index)
     {
-        delete cache.getValueAt(index).data;
-        cache.getValueAt(index).data = nullptr;
-    }
-    cache.clear();
-}
-
-/*
-Function: refreshCache
-Description: Refreshes the cache while preserving object addresses
-             for records that already exist. Existing objects are
-             updated in-place so that pointers held elsewhere remain
-             valid after the refresh.
-Parameters:
-    - cache: Existing cache to refresh.
-    - refreshedCache: Newly loaded cache contents.
-Returns:
-    - None
-*/
-template<typename TObject>
-void DataStore::refreshCache(util::Map<std::string, TrackedRecord<TObject>>& cache, util::Map<std::string, TrackedRecord<TObject>>& refreshedCache)
-{
-    util::Map<std::string, TrackedRecord<TObject>> oldCache = cache;
-    cache.clear();
-    for (int index = 0; index < refreshedCache.getSize(); ++index)
-    {
-        const std::string& id = refreshedCache.getKeyAt(index);
-        TrackedRecord<TObject>& refreshedRecord = refreshedCache.getValueAt(index);
-        int oldIndex = oldCache.find(id);
-        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;
-            delete refreshedRecord.data;
-            refreshedRecord.data = oldRecord.data;
-        }
-        cache.insert(id, refreshedRecord);
-    }
-    for (int index = 0; index < oldCache.getSize(); ++index)
-    {
-        const std::string& id = oldCache.getKeyAt(index);
-        const TrackedRecord<TObject>& localTrackedRecord = oldCache.getValueAt(index);
-        if (cache.find(id) == -1)
-        {
-            if (localTrackedRecord.state == RecordState::NEW_RECORD)
-            {
-                cache.insert(id, localTrackedRecord);
-            }
-            else
-            {
-                delete localTrackedRecord.data;
-            }
-        }
+        delete records.getValueAt(index).data;
+        records.getValueAt(index).data = nullptr;
     }
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/datastores/DataStoreLockGuard.h

@@ -1,28 +0,0 @@
-/*
-File: DataStoreLockGuard.h
-Description: Defines the DataStoreLockGuard class used to manage DataStore
-             locking and unlocking automatically within a scope.
-Author: Trenser
-Date: 12-June-2026
-*/
-
-#pragma once
-#include "DataStore.h"
-
-class DataStoreLockGuard
-{
-public:
-    explicit DataStoreLockGuard(DataStore& dataStore)
-        : m_dataStore(dataStore)
-    {
-        m_dataStore.lockDataStore();
-    }
-    ~DataStoreLockGuard()
-    {
-        m_dataStore.unlockDataStore();
-    }
-    DataStoreLockGuard(const DataStoreLockGuard&) = delete;
-    DataStoreLockGuard& operator=(const DataStoreLockGuard&) = delete;
-private:
-    DataStore& m_dataStore;
-};

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/datastores/sharedmemory/SharedMemory.cpp

@@ -10,7 +10,6 @@ Created: 11-June-2026
 */
 
 #include "SharedMemory.h"
-#include "Windows.h"
 #include "Config.h"
 
 /*
@@ -320,7 +319,7 @@ bool SharedMemory::ensureCapacityForInsert(MappingInfo& mapping)
     {
         return true;
     }
-    return resizeMapping(mapping, capacity * config::file::GROWTH_FACTOR);
+    return resizeMapping(mapping, capacity * 2);
 }
 
 /*

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/ComboPackage.h

@@ -12,7 +12,7 @@ Date: 19-May-2026
 #include "Enums.h"
 
 class Service;
-struct SerializedComboPackage;
+class SerializedComboPackage;
 
 class ComboPackage
 {

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/InventoryItem.cpp

@@ -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";
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/InventoryItem.h

@@ -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();
 };

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

@@ -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
@@ -59,16 +57,16 @@ Returns:
 Invoice::Invoice(
     const std::string& bookingId,
     ServiceBooking* booking,
-    const util::Timestamp& invoiceDate,
-    double laborCost,
+    const util::Timestamp& invoiceDate, 
+    double laborCost, 
     const util::Map<std::string, InventoryItem*>& parts,
     double partsCost,
-    double discountPercentage,
-    double totalAmount,
-    const util::Timestamp& paymentDate,
-    util::PaymentMode paymentMethod,
+    double discountPercentage, 
+    double totalAmount, 
+    const util::Timestamp& paymentDate, 
+    util::PaymentMode paymentMethod, 
     util::PaymentStatus status
-)
+    )
     : m_id("INV" + std::to_string(++m_uid)),
     m_bookingId(bookingId),
     m_booking(booking),
@@ -80,7 +78,7 @@ Invoice::Invoice(
     m_totalAmount(totalAmount),
     m_paymentDate(paymentDate),
     m_paymentMethod(paymentMethod),
-    m_status(status)
+    m_status(status) 
 {
     int numberOfParts = m_parts.getSize();
     auto partPointers = m_parts.getValues();
@@ -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";
 }

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

@@ -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
 {
@@ -39,14 +39,14 @@ public:
     Invoice(
         const std::string& bookingId,
         ServiceBooking* booking,
-        const util::Timestamp& invoiceDate,
-        double laborCost,
-        const util::Map<std::string, InventoryItem*>& parts,
+        const util::Timestamp& invoiceDate, 
+        double laborCost, 
+        const util::Map<std::string,InventoryItem*>& parts,
         double partsCost,
-        double discountPercentage,
-        double totalAmount,
-        const util::Timestamp& paymentDate,
-        util::PaymentMode paymentMethod,
+        double discountPercentage, 
+        double totalAmount, 
+        const util::Timestamp& paymentDate, 
+        util::PaymentMode paymentMethod, 
         util::PaymentStatus status
     );
     Invoice(
@@ -87,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();
 };

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

@@ -1,13 +1,12 @@
 /*
 File: Notification.cpp
 Description: Implements the Notification class which represents system notifications in the Vehicle Service Management System.
-             Provides constructors, accessors, and mutators for notification details such as ID, recipientID, title, message, and timestamp.
+             Provides constructors, accessors, and mutators for notification details such as ID, recipient, title, message, and timestamp.
 Author: Trenser
 Date: 19-May-2026
 */
 
 #include <sstream>
-#include "SerializedRecords.h"
 #include "Notification.h"
 #include "StringHelper.h"
 #include "Factory.h"
@@ -23,8 +22,8 @@ Returns:
     - A new Notification object.
 */
 Notification::Notification()
-    : m_id("NOT" + std::to_string(++m_uid)), 
-    m_state(util::State::ACTIVE) {}
+    : m_id("NOT" + std::to_string(++m_uid)),
+    m_recipient(nullptr) {}
 
 /*
 Function: Notification
@@ -38,14 +37,13 @@ Parameters:
 Returns:
     - A new Notification object.
 */
-Notification::Notification(const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt)
+Notification::Notification(const std::string& recipientUserId, User* recipient, const std::string& title, const std::string& message, const util::Timestamp& createdAt)
     : m_id("NOT" + std::to_string(++m_uid)),
     m_recipientUserId(recipientUserId),
+    m_recipient(recipient),
     m_title(title),
     m_message(message),
-    m_state(util::State::ACTIVE),
-    m_createdAt(createdAt) {
-}
+    m_createdAt(createdAt) {}
 
 /*
 Function: Notification (parameterized constructor with ID)
@@ -60,13 +58,13 @@ Parameters:
 Returns:
     - A new Notification object
 */
-Notification::Notification(const std::string& id, const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt, const util::State& state)
+Notification::Notification(const std::string& id, const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt)
     : m_id(id),
     m_recipientUserId(recipientUserId),
+    m_recipient(nullptr),
     m_title(title),
     m_message(message),
-    m_createdAt(createdAt),
-    m_state(state)
+    m_createdAt(createdAt) 
 {
     int idNumber = util::extractNumber(m_id);
     if (idNumber > m_uid)
@@ -81,7 +79,7 @@ Description: Retrieves the unique ID of the notification.
 Returns:
     - const std::string& representing the notification ID.
 */
-const std::string& Notification::getId() const
+const std::string& Notification::getId() const 
 {
     return m_id;
 }
@@ -97,6 +95,17 @@ const std::string& Notification::getRecipientUserId() const
     return m_recipientUserId;
 }
 
+/*
+Function: getRecipient
+Description: Retrieves the pointer to the recipient user.
+Returns:
+    - User* representing the recipient.
+*/
+User* Notification::getRecipient() const
+{
+    return m_recipient;
+}
+
 /*
 Function: getTitle
 Description: Retrieves the title of the notification.
@@ -130,17 +139,6 @@ const util::Timestamp& Notification::getCreatedAt() const
     return m_createdAt;
 }
 
-/*
-Function: getState
-Description: Retrieves the Notification state
-Returns:
-    - const util::Timestamp& representing the creation timestamp.
-*/
-util::State Notification::getState() const
-{
-    return m_state;
-}
-
 /*
 Function: setId
 Description: Sets the unique ID of the notification.
@@ -167,6 +165,19 @@ void Notification::setRecipientUserId(const std::string& recipientUserId)
     m_recipientUserId = recipientUserId;
 }
 
+/*
+Function: setRecipient
+Description: Sets the recipient user pointer for the notification.
+Parameters:
+    - recipient: Pointer to the User object.
+Returns:
+    - void
+*/
+void Notification::setRecipient(User* recipient)
+{
+    m_recipient = recipient;
+}
+
 /*
 Function: setTitle
 Description: Sets the title of the notification.
@@ -206,54 +217,71 @@ void Notification::setCreatedAt(const util::Timestamp& createdAt)
     m_createdAt = createdAt;
 }
 
-/*
-Function: setState
-Description: Sets the Notification state.
-Parameters:
-    - state: Notification state value.
-Returns:
-    - void
-*/
-void Notification::setState(util::State state)
-{
-    m_state = state;
-}
-
 /*
 Function: serialize
-Description: Serializes the Notification object into a SerializedNotification record.
+Description: Serializes the notification into a CSV-formatted string.
 Parameters:
     - None
 Returns:
-    - SerializedNotification: Serialized representation of the notification
+    - std::string: Serialized notification record
 */
-SerializedNotification Notification::serialize() const
+std::string Notification::serialize() const
 {
-    SerializedNotification serialized = {};
-    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
-    strcpy_s(serialized.recipientUserId, sizeof(serialized.recipientUserId), m_recipientUserId.c_str());
-    strcpy_s(serialized.title, sizeof(serialized.title), m_title.c_str());
-    strcpy_s(serialized.message, sizeof(serialized.message), m_message.c_str());
-    serialized.createdAt = m_createdAt;
-    serialized.state = m_state;
-    return serialized;
+    std::ostringstream serializedNotification;
+    serializedNotification << m_id << ','
+        << m_recipientUserId << ','
+        << m_title << ','
+        << m_message << ','
+        << m_createdAt.toString();
+    return serializedNotification.str();
 }
 
 /*
 Function: deserialize
-Description: Deserializes a SerializedNotification record into a Notification object.
+Description: Deserializes a CSV-formatted string into a Notification object.
 Parameters:
-    - serializedNotification: const SerializedNotification&, serialized notification record
+    - record: const std::string&, serialized notification record
 Returns:
     - Notification*: Pointer to the deserialized Notification object
+Throws:
+    - std::runtime_error if timestamp parsing fails
 */
-Notification* Notification::deserialize(const SerializedNotification& serializedNotification)
+Notification* Notification::deserialize(const std::string& record)
 {
+    std::string id, recipientUserId, title, message, createdAtTimestampString;
+    std::istringstream serializedNotification(record);
+    getline(serializedNotification, id, ',');
+    getline(serializedNotification, recipientUserId, ',');
+    getline(serializedNotification, title, ',');
+    getline(serializedNotification, message, ',');
+    getline(serializedNotification, createdAtTimestampString, ',');
+    util::Timestamp createdAtTimestamp;
+    try
+    {
+        createdAtTimestamp = util::Timestamp::fromString(createdAtTimestampString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid createdAt timestamp");
+    }
     return Factory::getObject<Notification>(
-        serializedNotification.id,
-        serializedNotification.recipientUserId,
-        serializedNotification.title,
-        serializedNotification.message,
-        serializedNotification.createdAt,
-        serializedNotification.state);
+        id,
+        recipientUserId,
+        title,
+        message,
+        createdAtTimestamp
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for notification serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,RecipientID,Title,Message,Timestamp")
+*/
+std::string Notification::getHeaders()
+{
+    return "ID,RecipientID,Title,Message,Timestamp";
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/Notification.h

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

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/User.cpp

@@ -8,7 +8,6 @@ Date: 19-May-2026
 */
 
 #include <sstream>
-#include "SerializedRecords.h"
 #include "User.h"
 #include "Notification.h"
 #include "Enums.h"
@@ -29,8 +28,7 @@ Returns:
 User::User()
     : m_id("USR" + std::to_string(++m_uid)),
     m_type(util::UserType::CUSTOMER),
-    m_status(util::State::ACTIVE) {
-}
+    m_status(util::State::ACTIVE) {}
 
 /*
 Function: User
@@ -53,8 +51,7 @@ User::User(const std::string& userName, const std::string& password, const std::
     m_phone(phone),
     m_email(email),
     m_type(role),
-    m_status(util::State::ACTIVE) {
-}
+    m_status(util::State::ACTIVE) {}
 
 /*
 Function: User (parameterized constructor with ID)
@@ -89,6 +86,23 @@ User::User(const std::string& userId, const std::string& userName, const std::st
     }
 }
 
+/*
+Function: ~User
+Description: Destructor that cleans up dynamically allocated notifications associated with the user.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+User::~User()
+{
+    auto values = m_notifications.getValues();
+    for (int index = 0; index < values.getSize(); index++)
+    {
+        delete values[index];
+    }
+}
+
 /*
 Function: getId
 Description: Retrieves the unique ID of the user.
@@ -155,6 +169,17 @@ const std::string& User::getEmail() const
     return m_email;
 }
 
+/*
+Function: getNotifications
+Description: Retrieves the map of notifications associated with the user.
+Returns:
+    - util::Map<std::string, Notification*>& representing the notifications.
+*/
+util::Map<std::string, Notification*>& User::getNotifications()
+{
+    return m_notifications;
+}
+
 /*
 Function: getUserType
 Description: Retrieves the role of the user.
@@ -255,6 +280,22 @@ void User::setEmail(const std::string& email)
     m_email = email;
 }
 
+/*
+Function: addNotification
+Description: Adds a new notification to the user’s notification map.
+Parameters:
+    - notification: Pointer to the Notification object.
+Returns:
+    - void
+*/
+void User::addNotification(Notification* notification)
+{
+    if (notification)
+    {
+        m_notifications.insert(notification->getId(), notification);
+    }
+}
+
 /*
 Function: setRole
 Description: Sets the role of the user.
@@ -283,43 +324,68 @@ void User::setState(util::State status)
 
 /*
 Function: serialize
-Description: Serializes the User object into a SerializedUser record.
+Description: Serializes the user into a CSV-formatted string.
 Parameters:
     - None
 Returns:
-    - SerializedUser: Serialized representation of the user
+    - std::string: Serialized user record
 */
-SerializedUser User::serialize() const
+std::string User::serialize() const
 {
-    SerializedUser serialized = {};
-    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
-    strcpy_s(serialized.username, sizeof(serialized.username), m_userName.c_str());
-    strcpy_s(serialized.password, sizeof(serialized.password), m_password.c_str());
-    strcpy_s(serialized.name, sizeof(serialized.name), m_name.c_str());
-    strcpy_s(serialized.phone, sizeof(serialized.phone), m_phone.c_str());
-    strcpy_s(serialized.email, sizeof(serialized.email), m_email.c_str());
-    serialized.userType = m_type;
-    serialized.status = m_status;
-    return serialized;
+    std::ostringstream serializedUser;
+    serializedUser << m_id << ','
+        << m_userName << ','
+        << m_password << ','
+        << m_name << ','
+        << m_phone << ','
+        << m_email << ','
+        << util::getUserTypeString(m_type) << ','
+        << util::getStateString(m_status);
+    return serializedUser.str();
 }
 
 /*
 Function: deserialize
-Description: Deserializes a SerializedUser record into a User object.
+Description: Deserializes a CSV-formatted string into a User object.
 Parameters:
-    - serializedUser: const SerializedUser&, serialized user record
+    - record: const std::string&, serialized user record
 Returns:
     - User*: Pointer to the deserialized User object
 */
-User* User::deserialize(const SerializedUser& serializedUser)
+User* User::deserialize(const std::string& record)
 {
-    return Factory::getObject<User>(
-        serializedUser.id,
-        serializedUser.username,
-        serializedUser.password,
-        serializedUser.name,
-        serializedUser.phone,
-        serializedUser.email,
-        serializedUser.userType,
-        serializedUser.status);
+    std::string id, name, username, phone, password, email;
+    std::string userTypeString, stateString;
+    std::istringstream serializedUser(record);
+    getline(serializedUser, id, ',');
+    getline(serializedUser, username, ',');
+    getline(serializedUser, password, ',');
+    getline(serializedUser, name, ',');
+    getline(serializedUser, phone, ',');
+    getline(serializedUser, email, ',');
+    getline(serializedUser, userTypeString, ',');
+    getline(serializedUser, stateString);
+    util::UserType userType = util::getUserType(userTypeString);
+    util::State status = util::getState(stateString);
+    return Factory::getObject<User>(id,
+        username,
+        password,
+        name,
+        phone,
+        email,
+        userType,
+        status);
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for user serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,Username,Password,Name,Phone,Email,UserType,UserStatus")
+*/
+std::string User::getHeaders()
+{
+    return "ID,Username,Password,Name,Phone,Email,UserType,UserStatus";
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/User.h

@@ -14,7 +14,6 @@ Date: 19-May-2026
 #include "Enums.h"
 
 class Notification;
-struct SerializedUser;
 
 class User : public Observer
 {
@@ -26,19 +25,21 @@ private:
     std::string m_name;
     std::string m_phone;
     std::string m_email;
+    util::Map<std::string, Notification*> m_notifications;
     util::UserType m_type;
     util::State m_status;
 public:
     User();
     User(const std::string& userName, const std::string& password, const std::string& name, const std::string& phone, const std::string& email, util::UserType role);
     User(const std::string& userId, const std::string& userName, const std::string& password, const std::string& name, const std::string& phone, const std::string& email, util::UserType role, util::State status);
-    ~User() = default;
+    ~User();
     const std::string& getId() const;
     const std::string& getUserName() const;
     const std::string& getPassword() const;
     const std::string& getName() const;
     const std::string& getPhone() const;
     const std::string& getEmail() const;
+    util::Map<std::string, Notification*>& getNotifications();
     util::UserType getUserType() const;
     util::State getState() const;
     void setId(const std::string& id);
@@ -47,8 +48,10 @@ public:
     void setName(const std::string& name);
     void setPhone(const std::string& phone);
     void setEmail(const std::string& email);
+    void addNotification(Notification* notification) override;
     void setRole(util::UserType role);
     void setState(util::State status);
-    SerializedUser serialize() const;
-    static User* deserialize(const SerializedUser& serializedUser);
+    std::string serialize() const;
+    static User* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

@@ -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;
 }

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

@@ -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);
 };

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

@@ -12,15 +12,14 @@ Date: 22-May-2026
 #include "Config.h"
 #include "Enums.h"
 #include "Factory.h"
+#include "FileManager.h"
 #include "InventoryItem.h"
 #include "InventoryManagementService.h"
-#include "AuthenticationManagementService.h"
 #include "Timestamp.h"
 #include "User.h"
 #include "Utility.h"
 #include "Vector.h"
-#include "DataStoreLockGuard.h"
-#include "EventManager.h"
+
 
 util::Map<std::string, User*> InventoryManagementService::m_observers{};
 
@@ -59,19 +58,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 +82,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);
@@ -92,6 +90,95 @@ void InventoryManagementService::sendLowStockAlerts()
 	}
 }
 
+/*
+Function: getObserverIDs
+Description: Retrieves the IDs of all observers currently attached to the
+			 InventoryManagementService.
+Parameters:
+	- None
+Returns:
+	- util::Vector<std::string>: Vector of observer user IDs
+*/
+util::Vector<std::string> InventoryManagementService::getObserverIDs()
+{
+	util::Vector<std::string> observerIDs;
+	int numberOfObservers = m_observers.getSize();
+	for (int index = 0; index < numberOfObservers; index++)
+	{
+		User* observer = m_observers.getValueAt(index);
+		if (observer)
+		{
+			observerIDs.push_back(observer->getId());
+		}
+	}
+	return observerIDs;
+}
+
+/*
+Function: loadInventoryItems
+Description: Loads inventory items from persistent storage into the datastore.
+			 Uses FileManager to deserialize inventory items from the configured file.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void InventoryManagementService::loadInventoryItems()
+{
+	util::FileManager<InventoryItem> inventoryItemFileManager(config::file::INVENTORYITEM_FILE);
+	auto& inventoryItems = m_dataStore.getInventoryItems();
+	auto inventoryItemsMap = inventoryItemFileManager.load();
+	int numberOfInventoryItems = inventoryItemsMap.getSize();
+	for (int index = 0; index < numberOfInventoryItems; index++)
+	{
+		inventoryItems[inventoryItemsMap.getKeyAt(index)] = inventoryItemsMap.getValueAt(index);
+	}
+}
+
+/*
+Function: saveInventoryItems
+Description: Saves inventory items from the datastore to persistent storage.
+			 Uses FileManager to serialize inventory items into the configured file.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void InventoryManagementService::saveInventoryItems()
+{
+	util::FileManager<InventoryItem> inventoryItemFileManager(config::file::INVENTORYITEM_FILE);
+	auto& inventoryItems = m_dataStore.getInventoryItems();
+	inventoryItemFileManager.save(inventoryItems);
+}
+
+/*
+Function: loadObservers
+Description: Loads observer IDs from persistent storage and attaches corresponding
+			 users as observers to the InventoryManagementService.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void InventoryManagementService::loadObservers()
+{
+	util::loadObservers(config::file::INVENTORYMANAGEMENTOBSERVERS, this, m_dataStore);
+}
+
+/*
+Function: saveObservers
+Description: Saves the current observer IDs of the InventoryManagementService
+			 to persistent storage for future retrieval.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void InventoryManagementService::saveObservers()
+{
+	util::saveObservers(config::file::INVENTORYMANAGEMENTOBSERVERS, this);
+}
+
 /*
 Function: addInventoryItem
 Description: Creates a new inventory item using the Factory and inserts it
@@ -103,12 +190,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 +203,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 +223,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 +234,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 +253,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;
 }
 
 /*
@@ -214,9 +271,6 @@ Returns:
 */
 void InventoryManagementService::attach(User* user)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	m_observers.clear();
-	m_observers = m_dataStore.getInventoryManagementObservers();
 	if (user)
 	{
 		const std::string& userID = user->getId();
@@ -225,7 +279,6 @@ void InventoryManagementService::attach(User* user)
 			m_observers[userID] = user;
 		}
 	}
-	m_dataStore.saveInventoryManagementObservers(m_observers);
 }
 
 /*
@@ -238,9 +291,6 @@ Returns:
 */
 void InventoryManagementService::detach(User* user)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	m_observers.clear();
-	m_observers = m_dataStore.getInventoryManagementObservers();
 	if (user)
 	{
 		const std::string& userID = user->getId();
@@ -249,7 +299,6 @@ void InventoryManagementService::detach(User* user)
 			m_observers.remove(userID);
 		}
 	}
-	m_dataStore.saveInventoryManagementObservers(m_observers);
 }
 
 /*
@@ -266,28 +315,27 @@ Throws:
 */
 void InventoryManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
 {
-	if (!user)
+	if (user)
 	{
-		return;
+		if (m_observers.find(user->getId()) != -1)
+		{
+			Notification* notification =
+				Factory::getObject<Notification>(
+					user->getId(),
+					user,
+					title,
+					message,
+					util::Timestamp()
+				);
+			if (notification)
+			{
+				user->addNotification(notification);
+			}
+			else
+			{
+				throw std::runtime_error("Failed to create notification");
+			}
+		}
 	}
-	DataStoreLockGuard lock(m_dataStore);
-	m_observers = m_dataStore.getInventoryManagementObservers();
-	if (m_observers.find(user->getId()) == -1)
-	{
-		return;
-	}
-	auto& trackedNotificationsMap = m_dataStore.getNotifications();
-	Notification* notification = Factory::getObject<Notification>(
-		user->getId(),
-		title,
-		message,
-		util::Timestamp());
-	if (!notification)
-	{
-		throw std::runtime_error("Failed to create notification");
-	}
-	trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
-	m_dataStore.saveNotifications();
-	EventManager::sendNotificationAvailableEvent(user->getId());
 }
 

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

@@ -21,6 +21,7 @@ class InventoryManagementService : public NotificationManagementService
 private:
     DataStore& m_dataStore;
     static util::Map<std::string, User*> m_observers;
+    util::Vector<std::string> getObserverIDs() override;
 public:
     InventoryManagementService() : m_dataStore(DataStore::getInstance()) {}
     util::Map<std::string, InventoryItem*> getInventoryItems();
@@ -32,4 +33,8 @@ public:
     void sendNotification(User* user, const std::string& title, const std::string& message) override;
     void attach(User* user) override;
     void detach(User* user) override;
+    void loadInventoryItems();
+    void saveInventoryItems();
+    void loadObservers();
+    void saveObservers();
 };

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/NotificationManagementService.cpp

@@ -0,0 +1 @@
+#include "NotificationManagementService.h"

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/NotificationManagementService.h

@@ -19,4 +19,5 @@ public:
 	virtual void sendNotification(User* recipient, const std::string& title, const std::string& message) = 0;
 	virtual void attach(User* user) = 0;
 	virtual void detach(User* user) = 0;
+	virtual util::Vector<std::string> getObserverIDs() = 0;
 };

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

@@ -11,19 +11,16 @@ Date: 20-May-2026
 #include "Config.h"
 #include "Enums.h"
 #include "Factory.h"
+#include "FileManager.h"
 #include "InventoryItem.h"
 #include "Invoice.h"
 #include "JobCard.h"
 #include "PaymentManagementService.h"
-#include "AuthenticationManagementService.h"
-#include "DataStoreLockGuard.h"
 #include "Service.h"
 #include "ServiceBooking.h"
 #include "Timestamp.h"
 #include "User.h"
 #include "Utility.h"
-#include "DataStoreLockGuard.h"
-#include "EventManager.h"
 
 util::Map<std::string, User*> PaymentManagementService::m_observers{};
 
@@ -37,9 +34,6 @@ Returns:
 */
 void PaymentManagementService::attach(User* user)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	m_observers.clear();
-	m_observers = m_dataStore.getPaymentManagementObservers();
 	if (user)
 	{
 		const std::string& userID = user->getId();
@@ -48,7 +42,6 @@ void PaymentManagementService::attach(User* user)
 			m_observers[userID] = user;
 		}
 	}
-	m_dataStore.savePaymentManagementObservers(m_observers);
 }
 
 /*
@@ -61,9 +54,6 @@ Returns:
 */
 void PaymentManagementService::detach(User* user)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	m_observers.clear();
-	m_observers = m_dataStore.getPaymentManagementObservers();
 	if (user)
 	{
 		const std::string& userID = user->getId();
@@ -72,7 +62,6 @@ void PaymentManagementService::detach(User* user)
 			m_observers.remove(userID);
 		}
 	}
-	m_dataStore.savePaymentManagementObservers(m_observers);
 }
 
 /*
@@ -89,29 +78,28 @@ Throws:
 */
 void PaymentManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
 {
-	if (!user)
+	if (user)
 	{
-		return;
+		if (m_observers.find(user->getId()) != -1)
+		{
+			Notification* notification =
+				Factory::getObject<Notification>(
+					user->getId(),
+					user,
+					title,
+					message,
+					util::Timestamp()
+				);
+			if (notification)
+			{
+				user->addNotification(notification);
+			}
+			else
+			{
+				throw std::runtime_error("Failed to create notification");
+			}
+		}
 	}
-	DataStoreLockGuard lock(m_dataStore);
-	m_observers = m_dataStore.getPaymentManagementObservers();
-	if (m_observers.find(user->getId()) == -1)
-	{
-		return;
-	}
-	auto& trackedNotificationsMap = m_dataStore.getNotifications();
-	Notification* notification = Factory::getObject<Notification>(
-		user->getId(),
-		title,
-		message,
-		util::Timestamp());
-	if (!notification)
-	{
-		throw std::runtime_error("Failed to create notification");
-	}
-	trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
-	m_dataStore.saveNotifications();
-	EventManager::sendNotificationAvailableEvent(user->getId());
 }
 
 /*
@@ -125,12 +113,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();
@@ -153,6 +140,123 @@ void PaymentManagementService::sendPaymentReminders()
 	}
 }
 
+/*
+Function: getObserverIDs
+Description: Retrieves the IDs of all observers currently attached to the
+             PaymentManagementService.
+Parameters:
+    - None
+Returns:
+    - util::Vector<std::string>: Vector of observer user IDs
+*/
+util::Vector<std::string> PaymentManagementService::getObserverIDs()
+{
+	util::Vector<std::string> observerIDs;
+	int numberOfObservers = m_observers.getSize();
+	for (int index = 0; index < numberOfObservers; index++)
+	{
+		User* observer = m_observers.getValueAt(index);
+		if (observer)
+		{
+			observerIDs.push_back(observer->getId());
+		}
+	}
+	return observerIDs;
+}
+
+/*
+Function: loadInvoices
+Description: Loads invoices from persistent storage into the datastore.
+             Validates associated service bookings and inventory parts before
+             attaching them to each invoice. Throws exceptions if invalid IDs
+             are encountered.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a booking ID or part ID is invalid
+*/
+void PaymentManagementService::loadInvoices()
+{
+    util::FileManager<Invoice> invoiceFileManager(config::file::INVOICE_FILE);
+    auto& invoices = m_dataStore.getInvoices();
+    auto& serviceBookings = m_dataStore.getServiceBookings();
+    auto& inventoryItems = m_dataStore.getInventoryItems();
+    auto invoicesMap = invoiceFileManager.load();
+    for (int invoiceIndex = 0; invoiceIndex < invoicesMap.getSize(); invoiceIndex++)
+    {
+        Invoice* invoice = invoicesMap.getValueAt(invoiceIndex);
+        int bookingIndex = serviceBookings.find(invoice->getBookingId());
+        if (bookingIndex == -1)
+        {
+            throw std::runtime_error("Invalid Booking ID");
+        }
+        ServiceBooking* booking = serviceBookings.getValueAt(bookingIndex);
+        invoice->setBooking(booking);
+        util::Map<std::string, InventoryItem*> invoiceParts;
+        auto& partIDs = invoice->getPartIDs();
+        for (int partIndex = 0; partIndex < partIDs.getSize(); partIndex++)
+        {
+            const std::string& partID = partIDs[partIndex];
+            int inventoryIndex = inventoryItems.find(partID);
+            if (inventoryIndex == -1)
+            {
+                throw std::runtime_error("Invalid Part ID");
+            }
+            invoiceParts[partID] = inventoryItems.getValueAt(inventoryIndex);
+        }
+        invoice->setParts(invoiceParts);
+        invoices[invoice->getId()] = invoice;
+    }
+}
+
+/*
+Function: saveInvoices
+Description: Saves invoices from the datastore to persistent storage.
+             Uses FileManager to serialize invoices into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void PaymentManagementService::saveInvoices()
+{
+    util::FileManager<Invoice> invoiceFileManager(config::file::INVOICE_FILE);
+    auto& invoices = m_dataStore.getInvoices();
+    invoiceFileManager.save(invoices);
+}
+
+/*
+Function: loadObservers
+Description: Loads observer IDs from persistent storage and attaches corresponding
+             users as observers to the PaymentManagementService.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if an observer ID is invalid (not found in datastore)
+*/
+void PaymentManagementService::loadObservers()
+{
+    util::loadObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this, m_dataStore);
+}
+
+/*
+Function: saveObservers
+Description: Saves the current observer IDs of the PaymentManagementService
+             to persistent storage for future retrieval.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void PaymentManagementService::saveObservers()
+{
+    util::saveObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this);
+}
+
 /*
 Function: createInventoryItemsMap (static helper)
 Description: Builds a map of inventory items required for a given service and adds them to the booking’s inventory map.
@@ -186,7 +290,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 +299,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 +322,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 +336,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 +363,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 +378,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 +412,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();
 }

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

@@ -22,15 +22,20 @@ class PaymentManagementService : public NotificationManagementService
 private:
     DataStore& m_dataStore;
     static util::Map<std::string, User*> m_observers;
+    util::Vector<std::string> getObserverIDs() override;
 public:
     PaymentManagementService() : m_dataStore(DataStore::getInstance()) {}
     void generateInvoice(ServiceBooking* booking);
     util::Map<std::string, Invoice*> getInvoices(const std::string& customerID);
     void completePayment(const std::string& invoiceID, util::PaymentMode paymentMode);
-    util::Map<std::string, Invoice*> getAllInvoices();
+    util::Map<std::string, Invoice*>& getAllInvoices();
     void confirmPayment(const std::string& invoiceID);
     void sendPaymentReminders();
     void sendNotification(User* user, const std::string& title, const std::string& message) override;
     void attach(User* user) override;
     void detach(User* user) override;
+    void loadInvoices();
+    void saveInvoices();
+    void loadObservers();
+    void saveObservers();
 };

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

@@ -23,6 +23,7 @@ class ServiceManagementService : public NotificationManagementService
 private:
     DataStore& m_dataStore;
     static util::Map<std::string, User*> m_observers;
+    util::Vector<std::string> getObserverIDs() override;
 public:
     ServiceManagementService() : m_dataStore(DataStore::getInstance()) {}
     util::Map<std::string, Service*> getServices();
@@ -35,7 +36,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);
@@ -45,4 +45,14 @@ public:
     void sendNotification(User* user, const std::string& title, const std::string& message) override;
     void attach(User* user) override;
     void detach(User* user) override;
+    void loadServices();
+    void saveServices();
+    void loadComboPackages();
+    void saveComboPackages();
+    void loadServiceBookings();
+    void saveServiceBookings();
+    void loadJobCards();
+    void saveJobCards();
+    void loadObservers();
+    void saveObservers();
 };

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

@@ -11,19 +11,15 @@ Date:19-May-2026
 #include "Config.h"
 #include "Enums.h"
 #include "Factory.h"
+#include "FileManager.h"
 #include "InventoryManagementService.h"
 #include "Notification.h"
 #include "PaymentManagementService.h"
 #include "ServiceManagementService.h"
-#include "AuthenticationManagementService.h"
 #include "User.h"
 #include "UserManagementService.h"
 #include "Vector.h"
 #include "Validator.h"
-#include "Utility.h"
-#include "TrackedRecord.h"
-#include "DataStoreLockGuard.h"
-#include "EventManager.h"
 
 /*
 Function: ensureAdminExists
@@ -35,13 +31,12 @@ Return type: void
 */
 void UserManagementService::ensureAdminExists()
 {
-	DataStoreLockGuard lock(m_dataStore);
 	auto& usersMap = m_dataStore.getUsers();
 	int usersMapSize = usersMap.getSize();
 	bool isAdminFound = false;
 	for (int index = 0; index < usersMapSize; index++)
 	{
-		User* user = usersMap.getValueAt(index).data;
+		User* user = usersMap.getValueAt(index);
 		if (user && user->getUserType() == util::UserType::ADMIN)
 		{
 			isAdminFound = true;
@@ -78,9 +73,7 @@ void UserManagementService::createUser(const std::string& username, const std::s
 	InventoryManagementService inventoryManagementService;
 	PaymentManagementService paymentManagementService;
 	ServiceManagementService serviceManagementService;
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	auto usersMap = util::getObjects(trackedUsersMap);
+	auto& usersMap = m_dataStore.getUsers();
 	if (util::isUsernameDuplicate(username, usersMap))
 	{
 		throw std::runtime_error("Username already exists");
@@ -94,14 +87,13 @@ void UserManagementService::createUser(const std::string& username, const std::s
 		throw std::runtime_error("Phone already exists");
 	}
 	User* newUser = Factory::getObject<User>(username, password, name, phone, email, type);
-	trackedUsersMap.insert(newUser->getId(), util::createNewRecord(newUser));
+	usersMap.insert(newUser->getId(), newUser);
 	paymentManagementService.attach(newUser);
 	serviceManagementService.attach(newUser);
 	if (newUser->getUserType() == util::UserType::ADMIN)
 	{
 		inventoryManagementService.attach(newUser);
 	}
-	m_dataStore.saveUsers();
 }
 
 /*
@@ -115,25 +107,19 @@ 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);
-	int index = trackedUsersMap.find(userID);
+	auto& usersMap = m_dataStore.getUsers();
+	int index = usersMap.find(userID);
 	if (index == -1)
 	{
 		throw std::runtime_error("User does not exist!\n");
 	}
-	User* user = trackedUsersMap.getValueAt(index).data;
-	bool isModified = false;
+	User* user = usersMap.getValueAt(index);
 	if (email != user->getEmail())
 	{
 		if (util::isEmailDuplicate(email, usersMap))
 		{
 			throw std::runtime_error("Email already exists!\n");
 		}
-		user->setEmail(email);
-		isModified = true;
 	}
 	if (phone != user->getPhone())
 	{
@@ -141,14 +127,9 @@ void UserManagementService::updateUserDetails(const std::string& userID, const s
 		{
 			throw std::runtime_error("Phone number already exists!\n");
 		}
-		user->setPhone(phone);
-		isModified = true;
-	}
-	if (isModified)
-	{
-		trackedUsersMap.getValueAt(index).state = RecordState::MODIFIED;
-		m_dataStore.saveUsers();
 	}
+	user->setEmail(email);
+	user->setPhone(phone);
 }
 
 /*
@@ -163,26 +144,20 @@ 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)
+	auto& usersMap = m_dataStore.getUsers();
+	if (usersMap.find(userID) == -1)
 	{
 		throw std::runtime_error("No user found with given UserID");
 	}
-	User* user = trackedUsersMap[userID].data;
+	User* user = usersMap[userID];
 	if (user)
 	{
-		auto& trackedNotificationMap = m_dataStore.getNotifications();
-		int numberOfNotifications = trackedNotificationMap.getSize();
+		auto& notifications = user->getNotifications();
+		int numberOfNotifications = notifications.getSize();
 		util::Vector<Notification*> notificationsVector;
 		for (int index = 0; index < numberOfNotifications; index++)
 		{
-			Notification* notification = trackedNotificationMap.getValueAt(index).data;
-			if (notification->getRecipientUserId() == userID && notification->getState() == util::State::ACTIVE)
-			{
-				notificationsVector.push_back(notification);
-			}
+		    notificationsVector.push_back(notifications.getValueAt(index));
 		}
 		return notificationsVector;
 	}
@@ -194,40 +169,97 @@ util::Vector<Notification*> UserManagementService::getUserNotifications(const st
 
 /*
 Function: deleteNotification
-Description: Marks a specific notification associated with a given user
-			 as inactive.
+Description: Deletes a specific notification associated with a given user ID.
 Parameters:
 	- notificationID: The unique ID of the notification to be deleted.
 	- userID: The unique ID of the user whose notification is to be deleted.
 Returns:
 	- void
 Throws:
-	- std::runtime_error if no user is found with the given UserID or
-	  if no notification is found with the given NotificationID.
+	- std::runtime_error if no user is found with the given UserID or if no notification is found with the given NotificationID.
 */
 void UserManagementService::deleteNotification(const std::string& notificationID, const std::string& userID)
 {
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	auto& trackedNotificationsMap = m_dataStore.getNotifications();
-	int userIndex = trackedUsersMap.find(userID);
-	if (userIndex == -1)
+	auto& usersMap = m_dataStore.getUsers();
+	if (usersMap.find(userID) == -1)
 	{
 		throw std::runtime_error("No user found with given UserID");
 	}
-	int notificationIndex = trackedNotificationsMap.find(notificationID);
-	if (notificationIndex == -1)
+	User* user = usersMap[userID];
+	auto& notifications = user->getNotifications();
+	if (notifications.find(notificationID) == -1)
 	{
 		throw std::runtime_error("No notification found with given NotificationID");
 	}
-	Notification* notification = trackedNotificationsMap.getValueAt(notificationIndex).data;
-	if (notification->getRecipientUserId() == userID)
-	{
-		notification->setState(util::State::INACTIVE);
-		trackedNotificationsMap.getValueAt(notificationIndex).state = RecordState::MODIFIED;
-		m_dataStore.saveNotifications();
-	}
+	notifications.remove(notificationID);
+}
+
+/*
+Function: loadUsers
+Description: Loads users and notifications from persistent storage into the datastore.
+             Validates that each notification’s recipient exists and attaches the
+             notification to the corresponding user.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a notification recipient user ID is invalid
+*/
+void UserManagementService::loadUsers()
+{
+    util::FileManager<User> userFileManager(config::file::USER_FILE);
+    util::FileManager<Notification> notificationFileManager(config::file::NOTIFICATION_FILE);
+    auto& users = m_dataStore.getUsers();
+    auto usersMap = userFileManager.load();
+    auto notificationsMap = notificationFileManager.load();
+    int numberOfUsers = usersMap.getSize();
+    int numberOfNotifications = notificationsMap.getSize();
+    for (int index = 0; index < numberOfUsers; index++)
+    {
+        users[usersMap.getKeyAt(index)] = usersMap.getValueAt(index);
+    }
+    for (int index = 0; index < numberOfNotifications; index++)
+    {
+        Notification* notification = notificationsMap.getValueAt(index);
+        const std::string& recipientUserId = notification->getRecipientUserId();
+        int userIndex = users.find(recipientUserId);
+        if (userIndex == -1)
+        {
+            throw std::runtime_error("Invalid recipient user ID");
+        }
+        User* user = users.getValueAt(userIndex);
+        user->addNotification(notification);
+    }
+}
+
+/*
+Function: saveUsers
+Description: Saves users and their notifications from the datastore to persistent storage.
+             Collects notifications from all users into a single map before saving.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void UserManagementService::saveUsers()
+{
+    util::FileManager<User> userFileManager(config::file::USER_FILE);
+    util::FileManager<Notification> notificationFileManager(config::file::NOTIFICATION_FILE);
+    auto& users = m_dataStore.getUsers();
+    util::Map<std::string, Notification*> notifications;
+    for (int userIndex = 0; userIndex < users.getSize(); userIndex++)
+    {
+        User* user = users.getValueAt(userIndex);
+        auto& userNotifications = user->getNotifications();
+        for (int notificationIndex = 0; notificationIndex < userNotifications.getSize(); notificationIndex++)
+        {
+            notifications[userNotifications.getKeyAt(notificationIndex)] =
+                userNotifications.getValueAt(notificationIndex);
+        }
+    }
+    userFileManager.save(users);
+    notificationFileManager.save(notifications);
 }
 
 /*
@@ -238,9 +270,7 @@ Return type: util::Map<std::string, User*>
 */
 util::Map<std::string, User*> UserManagementService::getUsers()
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto users = util::getObjects(m_dataStore.getUsers());
-	return users;
+	return m_dataStore.getUsers();
 }
 
 /*
@@ -251,12 +281,10 @@ Return type: User*
 */
 User* UserManagementService::getUser(const std::string& userID)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	int index = trackedUsersMap.find(userID);
+	int index = m_dataStore.getUsers().find(userID);
 	if (index != -1)
 	{
-		return trackedUsersMap.getValueAt(index).data;
+		return m_dataStore.getUsers().getValueAt(index);
 	}
 	return nullptr;
 }
@@ -269,65 +297,38 @@ Return type: void
 */
 void UserManagementService::removeUser(const std::string& userID)
 {
-    AuthenticationManagementService::ensureAuthorization();
 	InventoryManagementService inventoryManagementService;
 	PaymentManagementService paymentManagementService;
 	ServiceManagementService serviceManagementService;
-	std::string removedUserID;
+	int index = m_dataStore.getUsers().find(userID);
+	if (index != -1)
 	{
-		DataStoreLockGuard lock(m_dataStore);
-		auto& trackedUsersMap = m_dataStore.getUsers();
-		int index = trackedUsersMap.find(userID);
-		if (index != -1)
+		User* user = m_dataStore.getUsers().getValueAt(index);
+		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);
+			}
+			user->setState(util::State::INACTIVE);
+			inventoryManagementService.detach(user);
+			paymentManagementService.detach(user);
+			serviceManagementService.detach(user);
 		}
 	}
-	if (!removedUserID.empty())
-	{
-		EventManager::sendUserDisabledEvent(removedUserID);
-	}
 }
 
-/*
-Function: getUsers
-Description: Retrieves all active users of the specified type from
-			 the DataStore.
-Parameters:
-	- type: The user type to filter by
-			(ADMIN, CUSTOMER, or TECHNICIAN).
-Returns:
-	- util::Map<std::string, User*>:
-	  Collection of active users matching the specified type,
-	  keyed by user ID.
-*/
-util::Map<std::string, User*> UserManagementService::getUsers(util::UserType type) 
+util::Map<std::string, User*> UserManagementService::getUsers(util::UserType type)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	util::Map<std::string, User*> currentUsers = util::getObjects(trackedUsersMap);
+	util::Map<std::string, User*>& currentUsers = m_dataStore.getUsers();
 	util::Map<std::string, User*> filteredUsersMap;
-	for (int index = 0; index < currentUsers.getSize(); index++)
+	for (int iterator = 0; iterator < currentUsers.getSize(); iterator++)
 	{
-		User* currentUser = currentUsers.getValueAt(index);
+		User* currentUser = currentUsers.getValueAt(iterator);
 		if (currentUser && currentUser->getState() == util::State::ACTIVE && currentUser->getUserType() == type)
 		{
 			filteredUsersMap.insert(currentUser->getId(), currentUser);

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

@@ -31,4 +31,6 @@ public:
     util::Vector<Notification*> getUserNotifications(const std::string& userID);
     void deleteNotification(const std::string& notificationID, const std::string& userID);
     void ensureAdminExists();
+    void loadUsers();
+    void saveUsers();
 };

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

@@ -29,7 +29,6 @@ namespace config
 	namespace file
 	{
 		const size_t INITIAL_CAPACITY = 100;
-		const size_t GROWTH_FACTOR = 2;
 		constexpr const char* DIRECTORY = "files/";
 		constexpr const char* INVENTORYITEM_FILE = "files/InventoryItem.dat";
 		constexpr const char* USER_FILE = "files/User.dat";

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

@@ -43,4 +43,67 @@ namespace util
             position++;
         }
     }
+
+    /*
+    Function: loadRecords
+    Description: Loads records from a given file path into a vector of strings.
+                 Skips the header line if present. Creates the file if it does not exist.
+    Parameters:
+        - filePath: const std::string&, path to the file
+    Returns:
+        - util::Vector<std::string>: Vector containing all records (excluding header)
+    Throws:
+        - None (creates file if missing)
+    */
+    inline util::Vector<std::string> loadRecords(const std::string& filePath)
+    {
+        util::Vector<std::string> records;
+        std::ifstream file(filePath);
+        if (!file.is_open())
+        {
+            ensureDirectoryExists(filePath);
+            std::ofstream newFile(filePath);
+            newFile.close();
+            file.open(filePath);
+        }
+        std::string line;
+        bool isHeader = true;
+        while (std::getline(file, line))
+        {
+            if (isHeader)
+            {
+                isHeader = false;
+                continue;
+            }
+            records.push_back(line);
+        }
+        return records;
+    }
+
+    /*
+    Function: saveRecords
+    Description: Saves records to a given file path. Overwrites existing content
+                 and writes a header line followed by all records.
+    Parameters:
+        - filePath: const std::string&, path to the file
+        - records: const util::Vector<std::string>&, vector of records to save
+    Returns:
+        - void
+    Throws:
+        - std::runtime_error if the file cannot be opened for writing
+    */
+    inline void saveRecords(const std::string& filePath, const util::Vector<std::string>& records)
+    {
+        std::ofstream file(filePath, std::ios::trunc);
+        if (!file.is_open())
+        {
+            throw std::runtime_error("Failed to open file " + filePath);
+        }
+        file << "Values" << '\n';
+        int numberOfRecords = records.getSize();
+        for (int index = 0; index < numberOfRecords; index++)
+        {
+            file << records[index] << '\n';
+        }
+    }
 }

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

@@ -0,0 +1,119 @@
+/*
+File: FileManager.h
+Description: Declares and implements a generic FileManager template class for
+			 loading and saving objects to and from files. Uses serialization
+			 and deserialization methods defined in the object type T.
+			 Provides persistence support for system entities such as Users,
+			 Services, InventoryItems, etc.
+Author: Trenser
+Date: 22-May-2026
+*/
+
+#pragma once
+#include <stdexcept>
+#include <string>
+#include <fstream>
+#include "Vector.h"
+#include "Map.h"
+#include "FileHelper.h"
+
+namespace util
+{
+	template <typename T> using objects = util::Map<std::string, T*>;
+
+	template <typename T>
+	class FileManager
+	{
+	private:
+		std::string m_filePath;
+	public:
+		FileManager() : m_filePath("") {}
+		FileManager(const std::string& filePath) : m_filePath(filePath) {}
+		objects<T> load();
+		void save(const objects<T>&);
+	};
+
+	/*
+	Function: load
+	Description: Loads records from the file into a map of objects.
+				 Skips the header line, deserializes each record into an object of type T,
+				 and stores them in a map keyed by object ID.
+	Parameters:
+		- None
+	Returns:
+		- util::Map<std::string, T*> containing deserialized objects
+	Throws:
+		- std::runtime_error if deserialization fails for any record
+	*/
+	template <typename T>
+	objects<T> FileManager<T>::load()
+	{
+		objects<T> records;
+		std::ifstream file(m_filePath);
+		if (!file.is_open())
+		{
+			ensureDirectoryExists(m_filePath);
+			std::ofstream newFile(m_filePath);
+			newFile.close();
+			file.open(m_filePath);
+		}
+		util::Vector<std::string> lines;
+		std::string line;
+		while (std::getline(file, line))
+		{
+			lines.push_back(line);
+		}
+		int numberOfLines = lines.getSize();
+		bool isHeader = true;
+		for (int lineIndex = 0; lineIndex < numberOfLines; lineIndex++)
+		{
+			const auto& record = lines[lineIndex];
+			if (isHeader)
+			{
+				isHeader = false;
+				continue;
+			}
+			auto object = T::deserialize(record);
+			if (!object)
+			{
+				throw std::runtime_error("Failed to deserialize record");
+			}
+			records[object->getId()] = object;
+		}
+		return records;
+	}
+
+	/*
+	Function: save
+	Description: Saves records to the file. Serializes each object of type T into a string,
+				 writes a header line, and then writes all serialized records to the file.
+	Parameters:
+		- records: const util::Map<std::string, T*>&, map of objects to save
+	Returns:
+		- void
+	Throws:
+		- std::runtime_error if the file cannot be opened for writing
+	*/
+	template <typename T>
+	void FileManager<T>::save(const objects<T>& records)
+	{
+		util::Vector<std::string> lines;
+		lines.push_back(T::getHeaders());
+		int numberOfRecords = records.getSize();
+		for (int recordIndex = 0; recordIndex < numberOfRecords; recordIndex++)
+		{
+			const auto& record = records.getValueAt(recordIndex);
+			lines.push_back(record->serialize());
+		}
+		std::ofstream file(m_filePath, std::ios::trunc);
+		if (!file.is_open())
+		{
+			throw std::runtime_error("Failed to open file " + m_filePath);
+		}
+		int numberOfLines = lines.getSize();
+		for (int lineIndex = 0; lineIndex < numberOfLines; lineIndex++)
+		{
+			file << lines[lineIndex] << '\n';
+		}
+	}
+}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/InputHelper.h

@@ -28,7 +28,7 @@ namespace util
         if (!(std::cin >> value))
         {
             std::cin.clear();
-            std::cin.ignore((std::numeric_limits<std::streamsize>::max)(), '\n');
+            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
             throw std::runtime_error("Invalid console input");
         }
     }

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

@@ -54,79 +54,49 @@ namespace util
         return cost;
     }
 
-    template<typename TObject>
-    Map<std::string, TObject*> getObjects(const Map<std::string, TrackedRecord<TObject>>& trackedRecords);
-
-    template<typename TObject>
-    Map<std::string, const TObject*> getConstObjects(const Map<std::string, TrackedRecord<TObject>>& trackedRecords);
-
-    template<typename TObject>
-    TrackedRecord<TObject> createNewRecord(TObject* object);
-}
-
-/*
-Function: getObjects
-Description: Extracts the object pointers from a tracked-record
-             collection and returns them as a map keyed by the
-             same identifiers.
-Parameters:
-    - trackedRecords: Collection of tracked records.
-Returns:
-    - Map<std::string, TObject*>: Collection of object pointers.
-*/
-template<typename TObject>
-util::Map<std::string, TObject*> util::getObjects(const util::Map<std::string, TrackedRecord<TObject>>& trackedRecords)
-{
-    util::Map<std::string, TObject*> objects;
-    for (int index = 0; index < trackedRecords.getSize(); ++index)
+    /*
+    Function: loadObservers
+    Description: Loads observer IDs from a file and attaches the corresponding users
+                 to the notification management service. Validates that each observer ID
+                 exists in the datastore before attaching.
+    Parameters:
+        - filePath: const std::string&, path to the file containing observer IDs
+        - service: NotificationManagementService*, pointer to the notification service
+        - dataStore: DataStore&, reference to the datastore containing users
+    Returns:
+        - void
+    Throws:
+        - std::runtime_error if an observer ID is invalid (not found in datastore)
+    */
+    inline void loadObservers(const std::string& filePath, NotificationManagementService* service, DataStore& dataStore)
     {
-        const std::string& key = trackedRecords.getKeyAt(index);
-        TObject* object = trackedRecords.getValueAt(index).data;
-        objects.insert(key, object);
+        auto observerIDs = util::loadRecords(filePath);
+        auto& users = dataStore.getUsers();
+        for (int index = 0; index < observerIDs.getSize(); index++)
+        {
+            const std::string& observerID = observerIDs[index];
+            int userIndex = users.find(observerID);
+            if (userIndex == -1)
+            {
+                throw std::runtime_error("Invalid Observer ID");
+            }
+            service->attach(users.getValueAt(userIndex));
+        }
     }
-    return objects;
-}
 
-/*
-Function: getConstObjects
-Description: Extracts the object pointers from a tracked-record
-             collection and returns them as a read-only map
-             keyed by the same identifiers.
-Parameters:
-    - trackedRecords: Collection of tracked records.
-Returns:
-    - Map<std::string, const TObject*>:
-      Collection of read-only object pointers.
-*/
-template<typename TObject>
-util::Map<std::string, const TObject*> util::getConstObjects(
-    const util::Map<std::string, TrackedRecord<TObject>>& trackedRecords)
-{
-    util::Map<std::string, const TObject*> objects;
-    for (int index = 0; index < trackedRecords.getSize(); ++index)
+    /*
+    Function: saveObservers
+    Description: Saves the current observer IDs from the notification management service
+                 to a file for persistence.
+    Parameters:
+        - filePath: const std::string&, path to the file where observer IDs will be saved
+        - service: NotificationManagementService*, pointer to the notification service
+    Returns:
+        - void
+    */
+    inline void saveObservers(const std::string& filePath, NotificationManagementService* service)
     {
-        const std::string& key = trackedRecords.getKeyAt(index);
-        const TObject* object = trackedRecords.getValueAt(index).data;
-        objects.insert(key, object);
+        auto observerIDs = service->getObserverIDs();
+        util::saveRecords(filePath, observerIDs);
     }
-    return objects;
-}
-
-/*
-Function: createNewRecord
-Description: Creates a tracked record for a newly created
-             object. The record is initialized with
-             NEW_RECORD state.
-Parameters:
-    - object: Pointer to the newly created object.
-Returns:
-    - TrackedRecord<TObject>: Initialized tracked record.
-*/
-template<typename TObject>
-TrackedRecord<TObject> util::createNewRecord(TObject* object)
-{
-    TrackedRecord<TObject> record;
-    record.data = object;
-    record.state = RecordState::NEW_RECORD;
-    return record;
 }

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

@@ -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();

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

@@ -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();

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

@@ -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.

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

@@ -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();
-};
+};

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

@@ -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] = { NULL, NULL, NULL };
-    handles[0] = m_accountDisabledEvent;
-    handles[1] = m_notificationAvailableEvent;
-    handles[2] = m_shutdownEvent;
-    while (m_isMenuActive.load())
-    {
-        DWORD result = WaitForMultipleObjects(3, handles, FALSE, INFINITE);
-        switch (result)
-        {
-        case WAIT_OBJECT_0:
-            handleAccountDisabledEvent();
-            break;
-        case WAIT_OBJECT_0 + 1:
-            handleNotificationEvent();
-            break;
-        case WAIT_OBJECT_0 + 2:
-            return;
-        }
-    }
-}
-
-/*
-Function: stopEventListener
-Description: Stops the event listener thread and releases all
-             associated event handles.
-Parameter: None
-Return type: void
-*/
-void Menu::stopEventListener()
-{
-    m_isMenuActive.store(false);
-    if (m_shutdownEvent)
-    {
-        SetEvent(m_shutdownEvent);
-    }
-    if (m_eventListenerThread.joinable())
-    {
-        m_eventListenerThread.join();
-    }
-    if (m_accountDisabledEvent)
-    {
-        CloseHandle(m_accountDisabledEvent);
-    }
-    if (m_notificationAvailableEvent)
-    {
-        CloseHandle(m_notificationAvailableEvent);
-    }
-    if (m_shutdownEvent)
-    {
-        CloseHandle(m_shutdownEvent);
-    }
-    m_accountDisabledEvent = NULL;
-    m_notificationAvailableEvent = NULL;
-    m_shutdownEvent = NULL;
-}
-
-/*
-Function: handleAccountDisabledEvent
-Description: Handles an account disabled event by marking the menu
-             inactive and notifying the user.
-Parameter: None
-Return type: void
-*/
-void Menu::handleAccountDisabledEvent()
-{
-    m_isMenuActive.store(false);
-    const User* authenticatedUser = m_controller.getAuthenticatedUser();
-    std::string messageTitle = "Account Disabled";
-    if (authenticatedUser)
-    {
-        messageTitle += " - " + authenticatedUser->getName();
-    }
-    MessageBoxA(
-        GetConsoleWindow(),
-        "Your account has been disabled.",
-        messageTitle.c_str(),
-        MB_OK |
-        MB_ICONWARNING |
-        MB_SETFOREGROUND |
-        MB_TOPMOST);
-}

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

@@ -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();
-};

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

@@ -28,7 +28,6 @@ Date: 21-May-2026
 #include "Utility.h"
 #include "Validator.h"
 #include "Vector.h"
-#include "StringHelper.h"
 
 /*
 Function: displayAllServices
@@ -588,7 +587,7 @@ inline void displayInvoices(util::Map<std::string, const Invoice*> currentUserIn
                     << util::getPaymentStatusString(selectedInvoice->getStatus()) << std::endl;
                 std::cout << std::left << std::setw(20) << "Payment Mode:"
                     << util::getPaymentModeString(selectedInvoice->getPaymentMethod()) << std::endl;
-                auto& inventoryItemsInInvoice = selectedInvoice->getParts();
+                auto inventoryItemsInInvoice = selectedInvoice->getParts();
                 if (inventoryItemsInInvoice.isEmpty())
                 {
                     std::cout << "No inventory items used.\n\n";
@@ -597,6 +596,7 @@ inline void displayInvoices(util::Map<std::string, const Invoice*> currentUserIn
                 std::cout << "\nItems Used:\n";
                 std::cout << std::left
                     << std::setw(20) << "ItemName"
+                    << std::setw(10) << "Quantity"
                     << std::setw(10) << "Price"
                     << std::endl;
                 std::cout << std::string(40, '-') << std::endl;
@@ -605,6 +605,7 @@ inline void displayInvoices(util::Map<std::string, const Invoice*> currentUserIn
                     InventoryItem* currentItem = inventoryItemsInInvoice.getValueAt(iterator);
                     std::cout << std::left
                         << std::setw(20) << currentItem->getPartName()
+                        << std::setw(10) << currentItem->getQuantity()
                         << std::setw(10) << currentItem->getPrice()
                         << std::endl;
                 }
@@ -1055,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
@@ -1144,18 +1130,15 @@ inline void displayAllComboPackages(util::Map<std::string, const ComboPackage*>
     for (int index = 0; index < comboPackages.getSize(); index++)
     {
         const ComboPackage* currentComboPackage = comboPackages.getValueAt(index);
-        if (currentComboPackage) 
+        if (currentComboPackage && currentComboPackage->getState() != util::State::ACTIVE)
         {
-            if (currentComboPackage->getState() != util::State::ACTIVE)
-            {
-                continue;
-            }
-            std::cout << std::left
-                << std::setw(15) << currentComboPackage->getId()
-                << std::setw(35) << util::truncateString(currentComboPackage->getPackageName(), 30)
-                << std::setw(15) << util::calculateComboServiceEstimatedCost(currentComboPackage)
-                << std::endl;
+            continue;
         }
+        std::cout << std::left
+            << std::setw(15) << currentComboPackage->getId()
+            << std::setw(35) << util::truncateString(currentComboPackage->getPackageName(), 30)
+            << std::setw(15) << util::calculateComboServiceEstimatedCost(currentComboPackage)
+            << std::endl;
     }
 }
 
@@ -1181,21 +1164,18 @@ inline const ComboPackage* selectComboPackageFromPackages(const util::Map<std::s
     for (int index = 0; index < comboPackages.getSize(); index++)
     {
         const ComboPackage* currentComboPackage = comboPackages.getValueAt(index);
-        if (currentComboPackage)
+        if (currentComboPackage && currentComboPackage->getState() != util::State::ACTIVE)
         {
-            if (currentComboPackage->getState() != util::State::ACTIVE)
-            {
-                continue;
-            }
-            activeComboPackages.insert(currentIndex, currentComboPackage);
-            std::cout << std::left
-                << std::setw(10) << currentIndex
-                << std::setw(15) << currentComboPackage->getId()
-                << std::setw(35) << util::truncateString(currentComboPackage->getPackageName(), 30)
-                << std::setw(15) << util::calculateComboServiceEstimatedCost(currentComboPackage)
-                << std::endl;
-            currentIndex++;
+            continue;
         }
+        activeComboPackages.insert(currentIndex, currentComboPackage);
+        std::cout << std::left
+            << std::setw(10) << currentIndex
+            << std::setw(15) << currentComboPackage->getId()
+            << std::setw(35) << util::truncateString(currentComboPackage->getPackageName(), 30)
+            << std::setw(15) << util::calculateComboServiceEstimatedCost(currentComboPackage)
+            << std::endl;
+        currentIndex++;
     }
     if (activeComboPackages.getSize() == 0)
     {
@@ -1427,89 +1407,4 @@ inline std::string selectComboPackage(util::Map<std::string, const ComboPackage*
         std::cout << "Enter a valid choice.\n";
         return "";
     }
-}
-
-/*
-Function: displayNewNotification
-Description: Displays the most recent notification from the supplied
-             notification collection.
-Parameter: util::Vector<const Notification*> notifications -
-           collection of notifications
-           const std::string& - The name of the user currently authenticated with the system
-Return type: void
-*/
-inline void displayNewNotification(util::Vector<const Notification*> notifications, const std::string& name)
-{
-    const Notification* notification = nullptr;
-	size_t numberOfNotifications = notifications.getSize();
-	for (int index = 0; index < numberOfNotifications; index++)
-	{
-		if (!notification)
-		{
-			notification = notifications[index];
-		}
-		else
-		{
-            if (util::extractNumber(notification->getId()) < util::extractNumber(notifications[index]->getId()))
-			{
-				notification = notifications[index];
-			}
-		}
-	}
-    if (notification)
-    {
-        std::string messageTitle = notification->getTitle();
-        if (!name.empty())
-        {
-            messageTitle += " - " + name;
-        }
-        MessageBoxA(
-            GetConsoleWindow(),
-            notification->getMessage().c_str(),
-            messageTitle.c_str(),
-            MB_OK |
-            MB_ICONINFORMATION);
-    }
-}
-
-/*
-Function: verifyAllPaymentsCompleted
-Description: Checks whether the authenticated customer has completed
-             all payments for their invoices. Iterates through all
-             invoices belonging to the customer and verifies that
-             each invoice has a payment status of COMPLETED.
-Parameters: Controller& m_controller -
-            reference to the Controller object used to access
-            authenticated user and invoice data
-Return type: bool
-             true if all invoices for the authenticated customer
-             are completed, false if any invoice is pending or not completed
-Throws: std::runtime_error if no authenticated user is found
-*/
-inline bool verifyAllPaymentsCompleted(Controller& m_controller)
-{
-    const User* authenticatedUser = m_controller.getAuthenticatedUser();
-    if (!authenticatedUser)
-    {
-        throw std::runtime_error("No authenticated user found.");
-    }
-    const std::string& authenticatedUserId = authenticatedUser->getId();
-    util::Map<std::string, const Invoice*> listOfInvoices = m_controller.getAllInvoices();
-    for (int invoiceIndex = 0; invoiceIndex < listOfInvoices.getSize(); ++invoiceIndex)
-    {
-        const Invoice* invoice = listOfInvoices.getValueAt(invoiceIndex);
-        if (!invoice)
-        {
-            continue;
-        }
-        const std::string& customerId = invoice->getBooking()->getCustomerId();
-        if (customerId == authenticatedUserId)
-        {
-            if (invoice->getStatus() != util::PaymentStatus::COMPLETED)
-            {
-                return false;
-            }
-        }
-    }
-    return true;
-}
+}

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

@@ -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

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

@@ -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();

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

@@ -27,11 +27,8 @@ void UserInterface::run()
 {
 	try
 	{
-		if (!m_controller.initialize())
-		{
-			std::cout << "Error: Failed to initialize the system!";
-			return;
-		}
+		m_controller.loadSystemData();
+		m_controller.runSystemChecks();
 		bool isMenuActive = true;
 		while (isMenuActive)
 		{
@@ -52,7 +49,7 @@ void UserInterface::run()
 				util::pressEnter();
 			}
 		}
-		m_controller.shutdown();
+		m_controller.saveSystemData();
 	}
 	catch (const std::invalid_argument& exception)
 	{