changes

<UserStory> 1953: Model Refactoring </UserStory>

UserStory #1953

<Changes>
1. Replaced CSV-based Notification serialization and deserialization with SerializedNotification record-based serialization for shared memory storage.
2. Implemented Notification::serialize() to convert Notification objects into fixed-size SerializedNotification structures.
3. Implemented Notification::deserialize() to reconstruct Notification objects directly from SerializedNotification records.
4. Added Notification state persistence by introducing util::State support in constructors, serialization, and deserialization flows.
5. Updated Notification class interfaces to use SerializedNotification types instead of std::string serialization APIs.
6. Removed legacy CSV serialization support, including CSV parsing logic and header generation functionality.
7. Added SerializedNotification dependencies through SerializedRecords.h inclusion and forward declaration support.
8. Initialized Notification objects with ACTIVE state by default and added state getter/setter APIs.
</Changes>

<Test>
N/A
</Test>

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

.gitignore

@@ -427,5 +427,5 @@ FodyWeavers.xsd
 *.msm
 *.msp
 
-# DAT Files
+# CSV Files
-*.dat
+*.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" />
@@ -149,23 +148,21 @@
     <ClCompile Include="utilities\Validator.cpp" />
     <ClCompile Include="views\AdminMenu.cpp" />
     <ClCompile Include="views\CustomerMenu.cpp" />
-    <ClCompile Include="views\Menu.cpp" />
     <ClCompile Include="views\TechnicianMenu.cpp" />
     <ClCompile Include="views\UserInterface.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="controllers\Controller.h" />
-    <ClInclude Include="core\events\EventManager.h" />
     <ClInclude Include="core\patterns\Observer.h" />
     <ClInclude Include="core\patterns\Subject.h" />
-    <ClInclude Include="core\sharedmemory\FileHeader.h" />
-    <ClInclude Include="core\sharedmemory\MappingInfo.h" />
-    <ClInclude Include="core\sharedmemory\RecordState.h" />
-    <ClInclude Include="core\sharedmemory\SerializedRecords.h" />
-    <ClInclude Include="core\sharedmemory\SharedMemory.h" />
-    <ClInclude Include="core\sharedmemory\TrackedRecord.h" />
     <ClInclude Include="datastores\DataStore.h" />
     <ClInclude Include="datastores\DataStoreLockGuard.h" />
+    <ClInclude Include="datastores\sharedmemory\FileHeader.h" />
+    <ClInclude Include="datastores\sharedmemory\MappingInfo.h" />
+    <ClInclude Include="datastores\sharedmemory\RecordState.h" />
+    <ClInclude Include="datastores\sharedmemory\SerializedRecords.h" />
+    <ClInclude Include="datastores\sharedmemory\SharedMemory.h" />
+    <ClInclude Include="datastores\sharedmemory\TrackedRecord.h" />
     <ClInclude Include="factories\Factory.h" />
     <ClInclude Include="models\ComboPackage.h" />
     <ClInclude Include="models\InventoryItem.h" />
@@ -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">
+    <Filter Include="Header Files\DataStores\SharedMemory">
-      <UniqueIdentifier>{d9da9793-fe6f-4914-bee3-99d5934da228}</UniqueIdentifier>
+      <UniqueIdentifier>{ec639004-44c6-4bd6-9963-077adde82b5f}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Source Files\Core\SharedMemory">
+    <Filter Include="Source Files\DataStores\SharedMemory">
-      <UniqueIdentifier>{0769afb6-f57d-4ae3-a1cf-ceca6e606af0}</UniqueIdentifier>
+      <UniqueIdentifier>{7aa8722e-adfa-466e-8211-de63f3b7892b}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Header Files\Core\Events">
-      <UniqueIdentifier>{85029bdb-6941-41dc-a3a7-9e5841671d8c}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Source Files\Core\Events">
-      <UniqueIdentifier>{1050aca7-6f2c-4ccb-a446-db9c898c3599}</UniqueIdentifier>
     </Filter>
   </ItemGroup>
   <ItemGroup>
@@ -150,14 +144,8 @@
     <ClCompile Include="models\ComboPackage.cpp">
       <Filter>Source Files\Models</Filter>
     </ClCompile>
-    <ClCompile Include="core\sharedmemory\SharedMemory.cpp">
+    <ClCompile Include="datastores\sharedmemory\SharedMemory.cpp">
-      <Filter>Source Files\Core\SharedMemory</Filter>
+      <Filter>Source Files\DataStores\SharedMemory</Filter>
-    </ClCompile>
-    <ClCompile Include="core\events\EventManager.cpp">
-      <Filter>Source Files\Core\Events</Filter>
-    </ClCompile>
-    <ClCompile Include="views\Menu.cpp">
-      <Filter>Source Files\Views</Filter>
     </ClCompile>
   </ItemGroup>
   <ItemGroup>
@@ -254,6 +242,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 +257,26 @@
     <ClInclude Include="views\MenuHelper.h">
       <Filter>Header Files\Views</Filter>
     </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\FileHeader.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\MappingInfo.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\RecordState.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\TrackedRecord.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\SerializedRecords.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\SharedMemory.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
     <ClInclude Include="datastores\DataStoreLockGuard.h">
-      <Filter>Header Files\DataStores</Filter>
+      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="core\sharedmemory\FileHeader.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="core\sharedmemory\MappingInfo.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="core\sharedmemory\RecordState.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="core\sharedmemory\SerializedRecords.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="core\sharedmemory\SharedMemory.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="core\sharedmemory\TrackedRecord.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="core\events\EventManager.h">
-      <Filter>Header Files\Core\Events</Filter>
-    </ClInclude>
-    <ClInclude Include="views\Menu.h">
-      <Filter>Header Files\Views</Filter>
     </ClInclude>
   </ItemGroup>
 </Project>

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

@@ -234,17 +234,6 @@ void Controller::removeInventoryItem(const std::string& inventoryItemID)
     m_inventoryManagementService.removeInventoryItem(inventoryItemID);
 }
 
-/*
-Function: removeServiceBooking
-Description: Removes a service booking from the service management system by its booking ID.
-Parameter: const std::string& bookingID - ID of the service booking
-Return type: void
-*/
-void Controller::removeServiceBooking(const std::string& bookingID)
-{
-    m_serviceManagementService.removeServiceBooking(bookingID);
-}
-
 /*
 Function: addInventoryItemStock
 Description: Adds stock to an existing inventory item in the inventory management service.
@@ -276,7 +265,6 @@ util::Map<std::string, const ServiceBooking*> Controller::getServiceBookings()
     return readOnlyServiceBookings;
 }
 
-
 /*
 Function: getServiceBookingsByUser
 Description: Retrieves all service bookings for a specific user.
@@ -634,16 +622,3 @@ void Controller::shutdown()
     auto& dataStore = DataStore::getInstance();
     dataStore.shutdown();
 }
-
-/*
-Function: registerEvents
-Description: Registers menu event handles with the authentication
-             service.
-Parameter: HANDLE accountDisabledEvent - account disabled event handle
-           HANDLE notificationAvailableEvent - notification event handle
-Return type: void
-*/
-void Controller::registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent)
-{
-    m_authenticationManagementService.registerEvents(accountDisabledEvent, notificationAvailableEvent);
-}

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);
@@ -74,5 +72,4 @@ public:
     void configureNotifications(bool paymentNotifications, bool serviceNotifications);
     bool initialize();
     void shutdown();
-    void registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent);
 };

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

@@ -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,6 +7,8 @@ Date: 19-May-2026
 
 #pragma once
 
+class Notification;
+
 class Observer
 {
 public:

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

@@ -12,9 +12,6 @@ Date: 19-May-2026
 #include "Config.h"
 #include "SerializedRecords.h"
 #include "FileHelper.h"
-#include "ServiceBooking.h"
-#include "JobCard.h"
-#include "Invoice.h"
 
 /*
 Function: DataStore
@@ -147,6 +144,11 @@ bool DataStore::initialize()
             success = false;
             break;
         }
+        if (!SharedMemory::createOrOpenMapping(m_payments))
+        {
+            success = false;
+            break;
+        }
         if (!SharedMemory::createOrOpenMapping(m_serviceManagementObservers))
         {
             success = false;
@@ -191,6 +193,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);
@@ -255,28 +258,6 @@ Returns:
 */
 util::Map<std::string, TrackedRecord<Service>>& DataStore::getServices()
 {
-    util::Map<std::string, TrackedRecord<Service>> services = loadRecords<Service, SerializedService>(m_services);
-    refreshCache(m_serviceCache, services);
-    util::Map<std::string, TrackedRecord<InventoryItem>>& inventoryItems = getInventoryItems();
-    size_t numberOfServices = m_serviceCache.getSize();
-    for (int iteratorOne =0; iteratorOne < numberOfServices; iteratorOne++)
-    {
-        Service* currentService = m_serviceCache.getValueAt(iteratorOne).data;
-        util::Map<std::string, InventoryItem*> inventoryItemMap;
-        util::Vector<std::string> currentServiceInventoryItem = currentService->getRequiredInventoryItemIDs();
-        for (int iteratorTwo = 0; iteratorTwo < currentServiceInventoryItem.getSize(); iteratorTwo++)
-        {
-            const std::string& currentInventoryItemId = currentServiceInventoryItem[iteratorTwo];
-            int currentInventoryItemIndex = inventoryItems.find(currentInventoryItemId);
-            if (currentInventoryItemIndex == -1)
-            {
-                throw std::runtime_error("Invalid inventory item ID");
-            }
-            InventoryItem* currentItem = inventoryItems.getValueAt(currentInventoryItemIndex).data;
-            inventoryItemMap[currentInventoryItemId] = currentItem;
-        }
-        currentService->setRequiredInventoryItems(inventoryItemMap);
-    }
     return m_serviceCache;
 }
 
@@ -290,28 +271,6 @@ Returns:
 */
 util::Map<std::string, TrackedRecord<ComboPackage>>& DataStore::getComboPackages()
 {
-    util::Map<std::string, TrackedRecord<ComboPackage>> comboPackages = loadRecords<ComboPackage, SerializedComboPackage>(m_comboPackages);
-    refreshCache(m_comboPackageCache, comboPackages);
-    util::Map<std::string, TrackedRecord<Service>>& services = getServices();
-    size_t numberOfComboPackages = m_comboPackageCache.getSize();
-    for (int iteratorOne = 0; iteratorOne < numberOfComboPackages; iteratorOne++)
-    {
-        ComboPackage* currentComboPackage =  m_comboPackageCache.getValueAt(iteratorOne).data;
-        util::Vector<std::string> currentServiceIds = currentComboPackage->getServiceIDs();
-        util::Map<std::string, Service*> currentComboPackageServices;
-        for (int iteratorTwo = 0; iteratorTwo < currentServiceIds.getSize(); iteratorTwo++)
-        {
-            const std::string& currentServiceId = currentServiceIds[iteratorTwo];
-            int serviceIndex = services.find(currentServiceId);
-            if (serviceIndex == -1)
-            {
-                throw std::runtime_error("Invalid service ID");
-            }
-            Service* currentService = services.getValueAt(serviceIndex).data;
-            currentComboPackageServices[currentServiceId] = currentService;
-        }
-        currentComboPackage->setServices(currentComboPackageServices);
-    }
     return m_comboPackageCache;
 }
 
@@ -325,8 +284,6 @@ Returns:
 */
 util::Map<std::string, TrackedRecord<InventoryItem>>& DataStore::getInventoryItems()
 {
-    auto inventoryItems = loadRecords<InventoryItem, SerializedInventoryItem>(m_inventoryItems);
-    refreshCache(m_inventoryItemCache, inventoryItems);
     return m_inventoryItemCache;
 }
 
@@ -340,49 +297,6 @@ Returns:
 */
 util::Map<std::string, TrackedRecord<ServiceBooking>>& DataStore::getServiceBookings()
 {
-    util::Map<std::string, TrackedRecord<ServiceBooking>> serviceBookings = loadRecords<ServiceBooking, SerializedServiceBooking>(m_serviceBookings);
-    refreshCache(m_serviceBookingCache, serviceBookings);
-    auto& users = getUsers();
-    auto& services = getServices();
-    size_t numberOfServiceBookings = m_serviceBookingCache.getSize();
-    for (int iteratorOne = 0; iteratorOne < numberOfServiceBookings; iteratorOne++)
-    {
-        ServiceBooking* serviceBooking = m_serviceBookingCache.getValueAt(iteratorOne).data;
-        auto& serviceIds = serviceBooking->getServiceIDs();
-        util::Map<std::string, Service*> servicesInBooking;
-        for (int iteratorTwo = 0; iteratorTwo < serviceIds.getSize(); iteratorTwo++)
-        {
-            const std::string& currentServiceId = serviceIds[iteratorTwo];
-            int serviceIndex = services.find(currentServiceId);
-            if (serviceIndex == -1)
-            {
-                throw std::runtime_error("Invalid service index.");
-            }
-            auto& currentService = services.getValueAt(serviceIndex);
-            servicesInBooking[currentServiceId] = currentService.data;
-        }
-        serviceBooking->setServices(servicesInBooking);
-        if (!serviceBooking->getCustomerId().empty())
-        {
-            int userIndex = users.find(serviceBooking->getCustomerId());
-            if (userIndex == -1)
-            {
-                throw std::runtime_error("Invalid user index.");
-            }
-            auto& customer = users.getValueAt(userIndex);
-            serviceBooking->setCustomer(customer.data);
-        }
-        if (!serviceBooking->getAssignedTechnicianId().empty())
-        {
-            int technicianIndex = users.find(serviceBooking->getAssignedTechnicianId());
-            if (technicianIndex == -1)
-            {
-                throw std::runtime_error("Invalid technician index.");
-            }
-            auto& technician = users.getValueAt(technicianIndex);
-            serviceBooking->setAssignedTechnician(technician.data);
-        }
-    }
     return m_serviceBookingCache;
 }
 
@@ -396,51 +310,9 @@ Returns:
 */
 util::Map<std::string, TrackedRecord<JobCard>>& DataStore::getJobCards()
 {
-    util::Map<std::string, TrackedRecord<JobCard>> jobCards = loadRecords<JobCard, SerializedJobCard>(m_jobCards);
-    refreshCache(m_jobCardCache, jobCards);
-    auto& serviceBookings = getServiceBookings();
-    auto& services = getServices();
-    auto& users = getUsers();
-    int numberOfJobCards = m_jobCardCache.getSize();
-    for (int iterator = 0; iterator < numberOfJobCards; iterator++)
-    {
-        JobCard* jobCard = m_jobCardCache.getValueAt(iterator).data;
-        if (!jobCard)
-        {
-            continue;
-        }
-        const std::string& bookingId = jobCard->getBookingId();
-        int bookingIndex = serviceBookings.find(bookingId);
-        if (bookingIndex == -1)
-        {
-            throw std::runtime_error("Invalid booking ID: " + bookingId);
-        }
-        auto& trackedBooking = serviceBookings.getValueAt(bookingIndex);
-        jobCard->setBooking(trackedBooking.data);
-        const std::string& serviceId = jobCard->getServiceId();
-        int serviceIndex = services.find(serviceId);
-        if (serviceIndex == -1)
-        {
-            throw std::runtime_error("Invalid service ID: " + serviceId);
-        }
-        auto& trackedService = services.getValueAt(serviceIndex);
-        jobCard->setService(trackedService.data);
-        const std::string& technicianId = jobCard->getTechnicianId();
-        if (!technicianId.empty())
-        {
-            int technicianIndex = users.find(technicianId);
-            if (technicianIndex == -1)
-            {
-                throw std::runtime_error("Invalid technician ID: " + technicianId);
-            }
-            auto& trackedTechnician = users.getValueAt(technicianIndex);
-            jobCard->setTechnician(trackedTechnician.data);
-        }
-    }
     return m_jobCardCache;
 }
 
-
 /*
 Function: getInvoices
 Description: Retrieves all invoice records from the datastore.
@@ -451,45 +323,6 @@ Returns:
 */
 util::Map<std::string, TrackedRecord<Invoice>>& DataStore::getInvoices()
 {
-    auto& serviceBookings = getServiceBookings();
-    auto& inventoryItems = getInventoryItems();
-    util::Map<std::string, TrackedRecord<Invoice>> invoices = loadRecords<Invoice, SerializedInvoice>(m_invoices);
-    refreshCache(m_invoiceCache, invoices);
-    for (int iterator = 0; iterator < m_invoiceCache.getSize(); iterator++)
-    {
-        auto& trackedInvoice = m_invoiceCache.getValueAt(iterator);
-        Invoice* invoice = trackedInvoice.data;
-        if (!invoice)
-        {
-            continue;
-        }
-        const std::string& currentBookingId = invoice->getBookingId();
-        int currentBookingIndex = serviceBookings.find(currentBookingId);
-        if (currentBookingIndex == -1)
-        {
-            throw std::runtime_error("Invalid Service Booking Index.");
-        }
-        ServiceBooking* currentBooking = serviceBookings.getValueAt(currentBookingIndex).data;
-        auto& currentInventoryItemIds = invoice->getPartIDs();
-        util::Map<std::string, InventoryItem*> currentInventoryItems;
-        for (int iterator = 0; iterator < currentInventoryItemIds.getSize(); iterator++)
-        {
-            const std::string& currentItemId = currentInventoryItemIds[iterator];
-            int currentItemIndex = inventoryItems.find(currentItemId);
-            if (currentItemIndex == -1)
-            {
-                throw std::runtime_error("Invalid Inventory item id.");
-            }
-            InventoryItem* currentItem = inventoryItems.getValueAt(currentItemIndex).data;
-            if (!currentItem)
-            {
-                continue;
-            }
-            currentInventoryItems[currentItemId] = currentItem;
-        }
-        invoice->setBooking(currentBooking);
-        invoice->setParts(currentInventoryItems);
-    }
     return m_invoiceCache;
 }
 
@@ -599,7 +432,6 @@ Returns:
 */
 void DataStore::saveServices()
 {
-    saveRecords<Service, SerializedService>(m_services, m_serviceCache);
 }
 
 /*
@@ -612,7 +444,6 @@ Returns:
 */
 void DataStore::saveComboPackages()
 {
-    saveRecords<ComboPackage, SerializedComboPackage>(m_comboPackages, m_comboPackageCache);
 }
 
 /*
@@ -625,7 +456,6 @@ Returns:
 */
 void DataStore::saveInventoryItems()
 {
-    saveRecords<InventoryItem, SerializedInventoryItem>(m_inventoryItems, m_inventoryItemCache);
 }
 
 /*
@@ -638,7 +468,6 @@ Returns:
 */
 void DataStore::saveServiceBookings()
 {
-    saveRecords<ServiceBooking, SerializedServiceBooking>(m_serviceBookings, m_serviceBookingCache);
 }
 
 /*
@@ -651,7 +480,6 @@ Returns:
 */
 void DataStore::saveJobCards()
 {
-    saveRecords<JobCard, SerializedJobCard>(m_jobCards, m_jobCardCache);
 }
 
 /*
@@ -664,7 +492,6 @@ Returns:
 */
 void DataStore::saveInvoices()
 {
-    saveRecords<Invoice, SerializedInvoice>(m_invoices, m_invoiceCache);
 }
 
 /*
@@ -691,9 +518,9 @@ void DataStore::saveObservers(MappingInfo& mapping, util::Map<std::string, User*
     SharedMemory::setRecordCount(mapping, observerCount);
     for (size_t index = 0; index < observerCount; index++)
     {
-        SerializedObserver serializedObserver{};
+        SerializedObserver serializedObserver;
         User* user = observers.getValueAt(static_cast<int>(index));
-        strcpy_s(serializedObserver.id, sizeof(serializedObserver.id), user->getId().c_str());
+        strcpy_s(serializedObserver.id, user->getId().c_str());
         SerializedObserver* destination = static_cast<SerializedObserver*>(SharedMemory::getRecordAddress(mapping, index));
         *destination = serializedObserver;
     }
@@ -738,6 +565,32 @@ void DataStore::saveInventoryManagementObservers(util::Map<std::string, User*>&
     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;
+}
+
 /*
 Function: lockDataStore
 Description: Acquires the datastore mutex, providing
@@ -781,3 +634,4 @@ bool DataStore::unlockDataStore()
     }
     return ReleaseMutex(m_globalMutex) != 0;
 }
+

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

@@ -11,16 +11,15 @@ Date: 19-May-2026
 #include "Map.h"
 #include "MappingInfo.h"
 #include "TrackedRecord.h"
-#include "SerializedRecords.h"
 #include "SharedMemory.h"
-#include "User.h"
+class User;
-#include "Notification.h"
+class Notification;
-#include "Service.h"
+class Service;
-#include "ComboPackage.h"
+class ComboPackage;
-#include "InventoryItem.h"
+class InventoryItem;
-#include "ServiceBooking.h"
+class ServiceBooking;
-#include "JobCard.h"
+class JobCard;
-#include "Invoice.h"
+class Invoice;
 
 class DataStore
 {
@@ -40,6 +39,7 @@ private:
     MappingInfo m_serviceBookings;
     MappingInfo m_jobCards;
     MappingInfo m_invoices;
+    MappingInfo m_payments;
     MappingInfo m_serviceManagementObservers;
     MappingInfo m_paymentManagementObservers;
     MappingInfo m_inventoryManagementObservers;
@@ -220,12 +220,6 @@ void DataStore::refreshCache(util::Map<std::string, TrackedRecord<TObject>>& cac
         if (oldIndex != -1)
         {
             TrackedRecord<TObject>& oldRecord = oldCache.getValueAt(oldIndex);
-            if (oldRecord.state == RecordState::MODIFIED)
-            {
-                delete refreshedRecord.data;
-                cache.insert(id, oldRecord);
-                continue;
-            }
             *oldRecord.data = *refreshedRecord.data;
             oldRecord.slotIndex = refreshedRecord.slotIndex;
             oldRecord.state = refreshedRecord.state;
@@ -237,17 +231,9 @@ void DataStore::refreshCache(util::Map<std::string, TrackedRecord<TObject>>& cac
     for (int index = 0; index < oldCache.getSize(); ++index)
     {
         const std::string& id = oldCache.getKeyAt(index);
-        const TrackedRecord<TObject>& localTrackedRecord = oldCache.getValueAt(index);
         if (cache.find(id) == -1)
         {
-            if (localTrackedRecord.state == RecordState::NEW_RECORD)
+            delete oldCache.getValueAt(index).data;
-            {
-                cache.insert(id, localTrackedRecord);
-            }
-            else
-            {
-                delete localTrackedRecord.data;
-            }
         }
     }
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/ComboPackage.cpp

@@ -9,7 +9,6 @@ Date: 19-May-2026
 
 #include <sstream>
 #include <stdexcept>
-#include "SerializedRecords.h"
 #include "ComboPackage.h"
 #include "Service.h"
 #include "Factory.h"
@@ -29,8 +28,7 @@ Returns:
 ComboPackage::ComboPackage()
     : m_id("CMP" + std::to_string(++m_uid)),
     m_status(util::State::ACTIVE),
-    m_discountPercentage(0.0) {
+    m_discountPercentage(0.0) {}
-}
 
 /*
 Function: ComboPackage
@@ -272,38 +270,72 @@ static util::Vector<std::string> getServiceIDsAsVector(const std::string& servic
 
 /*
 Function: serialize
-Description: Serializes the ComboPackage object into a SerializedComboPackage record.
+Description: Serializes the combo package into a CSV-formatted string.
 Parameters:
     - None
 Returns:
-    - SerializedComboPackage: Serialized representation of the combo package
+    - std::string: Serialized combo package record
 */
-SerializedComboPackage ComboPackage::serialize() const
+std::string ComboPackage::serialize() const
 {
-    SerializedComboPackage serialized = {};
+    std::ostringstream serializedComboPackage;
-    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
+    serializedComboPackage << m_id << ','
-    strcpy_s(serialized.packageName, sizeof(serialized.packageName), m_packageName.c_str());
+        << m_packageName << ','
-    strcpy_s(serialized.serviceIDs, sizeof(serialized.serviceIDs), getServiceIDsAsString(m_serviceIDs).c_str());
+        << m_discountPercentage << ','
-    serialized.discountPercentage = m_discountPercentage;
+        << getServiceIDsAsString(m_serviceIDs) << ','
-    serialized.status = m_status;
+        << util::getStateString(m_status);
-    return serialized;
+    return serializedComboPackage.str();
 }
 
 /*
 Function: deserialize
-Description: Deserializes a SerializedComboPackage record into a ComboPackage object.
+Description: Deserializes a CSV-formatted string into a ComboPackage object.
 Parameters:
-    - serializedComboPackage: const SerializedComboPackage&, serialized combo package record
+    - record: const std::string&, serialized combo package record
 Returns:
     - ComboPackage*: Pointer to the deserialized ComboPackage object
+Throws:
+    - std::runtime_error if data is invalid
 */
-ComboPackage* ComboPackage::deserialize(const SerializedComboPackage& serializedComboPackage)
+ComboPackage* ComboPackage::deserialize(const std::string& record)
 {
-    util::Vector<std::string> serviceIDs = getServiceIDsAsVector(serializedComboPackage.serviceIDs);
+    std::string id, packageName;
+    std::string discountPercentageString, serviceIDsString, statusString;
+    double discountPercentage;
+    std::istringstream serializedComboPackage(record);
+    getline(serializedComboPackage, id, ',');
+    getline(serializedComboPackage, packageName, ',');
+    getline(serializedComboPackage, discountPercentageString, ',');
+    getline(serializedComboPackage, serviceIDsString, ',');
+    getline(serializedComboPackage, statusString, ',');
+    try
+    {
+        discountPercentage = std::stod(discountPercentageString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid combo package data");
+    }
+    util::Vector<std::string> serviceIDs = getServiceIDsAsVector(serviceIDsString);
+    util::State status = util::getState(statusString);
     return Factory::getObject<ComboPackage>(
-        serializedComboPackage.id,
+        id,
-        serializedComboPackage.packageName,
+        packageName,
-        serializedComboPackage.discountPercentage,
+        discountPercentage,
         serviceIDs,
-        serializedComboPackage.status);
+        status
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for combo package serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,PackageName,DiscountPercentage,ServiceIDs,Status")
+*/
+std::string ComboPackage::getHeaders()
+{
+    return "ID,PackageName,DiscountPercentage,ServiceIDs,Status";
 }

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

@@ -12,7 +12,6 @@ Date: 19-May-2026
 #include "Enums.h"
 
 class Service;
-struct SerializedComboPackage;
 
 class ComboPackage
 {
@@ -39,6 +38,7 @@ public:
     void setDiscountPercentage(double discountPercentage);
     void setServices(const util::Map<std::string, Service*>& services);
     void setState(util::State status);
-    SerializedComboPackage serialize() const;
+    std::string serialize() const;
-    static ComboPackage* deserialize(const SerializedComboPackage&);
+    static ComboPackage* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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 = {};
+    std::ostringstream serializedInventoryItem;
-    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
+    serializedInventoryItem << m_id << ','
-    strcpy_s(serialized.partName, sizeof(serialized.partName), m_partName.c_str());
+        << m_partName << ','
-    serialized.quantity = m_quantity;
+        << m_quantity << ','
-    serialized.price = m_price;
+        << m_price << ','
-    serialized.status = m_status;
+        << util::getStateString(m_status);
-    return serialized;
+    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,
+        id,
-        serializedInventoryItem.partName,
+        partName,
-        serializedInventoryItem.quantity,
+        quantity,
-        serializedInventoryItem.price,
+        price,
-        serializedInventoryItem.status);
+        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;
+    std::string serialize() const;
-    static InventoryItem* deserialize(const SerializedInventoryItem&);
+    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
@@ -68,7 +66,7 @@ Invoice::Invoice(
     const util::Timestamp& paymentDate, 
     util::PaymentMode paymentMethod, 
     util::PaymentStatus status
-)
+    )
     : m_id("INV" + std::to_string(++m_uid)),
     m_bookingId(bookingId),
     m_booking(booking),
@@ -475,50 +473,100 @@ static util::Vector<std::string> getPartIDsAsVector(const std::string& partIDsSt
 
 /*
 Function: serialize
-Description: Serializes the Invoice object into a SerializedInvoice record.
+Description: Serializes the invoice into a CSV-formatted string.
 Parameters:
     - None
 Returns:
-    - SerializedInvoice: Serialized representation of the invoice
+    - std::string: Serialized invoice record
 */
-SerializedInvoice Invoice::serialize() const
+std::string Invoice::serialize() const
 {
-    SerializedInvoice serialized = {};
+    std::ostringstream serializedInvoice;
-    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
+    serializedInvoice << m_id << ','
-    strcpy_s(serialized.bookingId, sizeof(serialized.bookingId), m_bookingId.c_str());
+        << m_bookingId << ','
-    strcpy_s(serialized.partIDs, sizeof(serialized.partIDs), getPartIDsAsString(m_partIDs).c_str());
+        << m_invoiceDate.toString() << ','
-    serialized.invoiceDate = m_invoiceDate;
+        << m_laborCost << ','
-    serialized.laborCost = m_laborCost;
+        << getPartIDsAsString(m_partIDs) << ','
-    serialized.partsCost = m_partsCost;
+        << m_partsCost << ','
-    serialized.discountPercentage = m_discountPercentage;
+        << m_discountPercentage << ','
-    serialized.totalAmount = m_totalAmount;
+        << m_totalAmount << ','
-    serialized.paymentDate = m_paymentDate;
+        << m_paymentDate.toString() << ','
-    serialized.paymentMethod = m_paymentMethod;
+        << util::getPaymentModeString(m_paymentMethod) << ','
-    serialized.status = m_status;
+        << util::getPaymentStatusString(m_status);
-    return serialized;
+    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,
+        id,
-        serializedInvoice.bookingId,
+        bookingId,
-        serializedInvoice.invoiceDate,
+        invoiceDate,
         partIDs,
-        serializedInvoice.laborCost,
+        laborCost,
-        serializedInvoice.partsCost,
+        partsCost,
-        serializedInvoice.discountPercentage,
+        discountPercentage,
-        serializedInvoice.totalAmount,
+        totalAmount,
-        serializedInvoice.paymentDate,
+        paymentDate,
-        serializedInvoice.paymentMethod,
+        paymentMethod,
-        serializedInvoice.status);
+        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
 {
@@ -41,7 +41,7 @@ public:
         ServiceBooking* booking,
         const util::Timestamp& invoiceDate, 
         double laborCost, 
-        const util::Map<std::string, InventoryItem*>& parts,
+        const util::Map<std::string,InventoryItem*>& parts,
         double partsCost,
         double discountPercentage, 
         double totalAmount, 
@@ -87,6 +87,7 @@ public:
     void setPaymentDate(const util::Timestamp& paymentDate);
     void setPaymentMethod(util::PaymentMode paymentMethod);
     void setStatus(util::PaymentStatus status);
-    SerializedInvoice serialize() const;
+    std::string serialize() const;
-    static Invoice* deserialize(const SerializedInvoice&);
+    static Invoice* deserialize(const std::string&);
+    static std::string getHeaders();
 };

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/JobCard.cpp

@@ -9,7 +9,6 @@ Date:19-May-2026
 
 #include <sstream>
 #include <stdexcept>
-#include "SerializedRecords.h"
 #include "JobCard.h"
 #include "Factory.h"
 #include "StringHelper.h"
@@ -29,8 +28,7 @@ JobCard::JobCard()
     m_booking(nullptr),
     m_service(nullptr),
     m_technician(nullptr),
-    m_status(util::ServiceJobStatus()) {
+    m_status(util::ServiceJobStatus()) {}
-}
 
 /*
 Function: JobCard
@@ -67,8 +65,7 @@ JobCard::JobCard(const std::string& bookingId,
     m_technician(technician),
     m_assignedDate(assignedDate),
     m_status(status),
-    m_completionDate(completionDate) {
+    m_completionDate(completionDate) {}
-}
 
 /*
 Function: JobCard (parameterized constructor with ID)
@@ -354,41 +351,79 @@ void JobCard::setCompletionDate(const util::Timestamp& completionDate)
 
 /*
 Function: serialize
-Description: Serializes the JobCard object into a SerializedJobCard record.
+Description: Serializes the job card into a CSV-formatted string.
 Parameters:
     - None
 Returns:
-    - SerializedJobCard: Serialized representation of the job card
+    - std::string: Serialized job card record
 */
-SerializedJobCard JobCard::serialize() const
+std::string JobCard::serialize() const
 {
-    SerializedJobCard serialized = {};
+    std::ostringstream serializedJobCard;
-    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
+    serializedJobCard << m_id << ','
-    strcpy_s(serialized.bookingId, sizeof(serialized.bookingId), m_bookingId.c_str());
+        << m_bookingId << ','
-    strcpy_s(serialized.serviceId, sizeof(serialized.serviceId), m_serviceId.c_str());
+        << m_serviceId << ','
-    strcpy_s(serialized.technicianId, sizeof(serialized.technicianId), m_technicianId.c_str());
+        << m_technicianId << ','
-    serialized.assignedDate = m_assignedDate;
+        << m_assignedDate.toString() << ','
-    serialized.status = m_status;
+        << util::getServiceJobStatusString(m_status) << ','
-    serialized.completionDate = m_completionDate;
+        << m_completionDate.toString();
-    return serialized;
+    return serializedJobCard.str();
 }
 
 /*
 Function: deserialize
-Description: Deserializes a SerializedJobCard record into a JobCard object.
+Description: Deserializes a CSV-formatted string into a JobCard object.
 Parameters:
-    - serializedJobCard: const SerializedJobCard&, serialized job card record
+    - record: const std::string&, serialized job card record
 Returns:
     - JobCard*: Pointer to the deserialized JobCard object
+Throws:
+    - std::runtime_error if timestamp parsing fails
 */
-JobCard* JobCard::deserialize(const SerializedJobCard& serializedJobCard)
+JobCard* JobCard::deserialize(const std::string& record)
 {
+    std::string id, bookingId, serviceId, technicianId;
+    std::string assignedDateString, statusString, completionDateString;
+    std::istringstream serializedJobCard(record);
+    getline(serializedJobCard, id, ',');
+    getline(serializedJobCard, bookingId, ',');
+    getline(serializedJobCard, serviceId, ',');
+    getline(serializedJobCard, technicianId, ',');
+    getline(serializedJobCard, assignedDateString, ',');
+    getline(serializedJobCard, statusString, ',');
+    getline(serializedJobCard, completionDateString, ',');
+    util::Timestamp assignedDate;
+    util::Timestamp completionDate;
+    try
+    {
+        assignedDate = util::Timestamp::fromString(assignedDateString);
+        completionDate = util::Timestamp::fromString(completionDateString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid timestamp");
+    }
+    util::ServiceJobStatus status = util::getServiceJobStatus(statusString);
     return Factory::getObject<JobCard>(
-        serializedJobCard.id,
+        id,
-        serializedJobCard.bookingId,
+        bookingId,
-        serializedJobCard.serviceId,
+        serviceId,
-        serializedJobCard.technicianId,
+        technicianId,
-        serializedJobCard.assignedDate,
+        assignedDate,
-        serializedJobCard.status,
+        status,
-        serializedJobCard.completionDate);
+        completionDate
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for job card serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,BookingID,ServiceID,TechnicianID,AssignedDate,Status,CompletionDate")
+*/
+std::string JobCard::getHeaders()
+{
+    return "ID,BookingID,ServiceID,TechnicianID,AssignedDate,Status,CompletionDate";
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/JobCard.h

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

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/Service.cpp

@@ -8,7 +8,6 @@ Date: 19-May-2026
 */
 
 #include <sstream>
-#include "SerializedRecords.h"
 #include "Service.h"
 #include "InventoryItem.h"
 #include "StringHelper.h"
@@ -28,8 +27,7 @@ Returns:
 Service::Service()
     : m_id("SRV" + std::to_string(++m_uid)),
     m_status(util::State::ACTIVE),
-    m_laborCost(0.0) {
+    m_laborCost(0.0) {}
-}
 
 /*
 Function: Service
@@ -268,38 +266,72 @@ static util::Vector<std::string> getInventoryItemIDsAsVector(const std::string&
 
 /*
 Function: serialize
-Description: Serializes the Service object into a SerializedService record.
+Description: Serializes the service into a CSV-formatted string.
 Parameters:
     - None
 Returns:
-    - SerializedService: Serialized representation of the service
+    - std::string: Serialized service record
 */
-SerializedService Service::serialize() const
+std::string Service::serialize() const
 {
-    SerializedService serialized = {};
+    std::ostringstream serializedService;
-    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
+    serializedService << m_id << ','
-    strcpy_s(serialized.name, sizeof(serialized.name), m_name.c_str());
+        << m_name << ','
-    strcpy_s(serialized.inventoryItemIDs, sizeof(serialized.inventoryItemIDs), getInventoryItemIDsAsString(m_requiredInventoryItemIDs).c_str());
+        << getInventoryItemIDsAsString(m_requiredInventoryItemIDs) << ','
-    serialized.laborCost = m_laborCost;
+        << m_laborCost << ','
-    serialized.status = m_status;
+        << util::getStateString(m_status);
-    return serialized;
+    return serializedService.str();
 }
 
 /*
 Function: deserialize
-Description: Deserializes a SerializedService record into a Service object.
+Description: Deserializes a CSV-formatted string into a Service object.
 Parameters:
-    - serializedService: const SerializedService&, serialized service record
+    - record: const std::string&, serialized service record
 Returns:
     - Service*: Pointer to the deserialized Service object
+Throws:
+    - std::runtime_error if labor cost parsing fails
 */
-Service* Service::deserialize(const SerializedService& serializedService)
+Service* Service::deserialize(const std::string& record)
 {
-    util::Vector<std::string> inventoryItemIDs = getInventoryItemIDsAsVector(serializedService.inventoryItemIDs);
+    std::string id, name;
+    std::string inventoryItemIDsString, laborCostString, statusString;
+    double laborCost;
+    std::istringstream serializedService(record);
+    getline(serializedService, id, ',');
+    getline(serializedService, name, ',');
+    getline(serializedService, inventoryItemIDsString, ',');
+    getline(serializedService, laborCostString, ',');
+    getline(serializedService, statusString, ',');
+    util::Vector<std::string> inventoryItemIDs = getInventoryItemIDsAsVector(inventoryItemIDsString);
+    try
+    {
+        laborCost = std::stod(laborCostString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid labor cost");
+    }
+    util::State status = util::getState(statusString);
     return Factory::getObject<Service>(
-        serializedService.id,
+        id,
-        serializedService.name,
+        name,
         inventoryItemIDs,
-        serializedService.laborCost,
+        laborCost,
-        serializedService.status);
+        status
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for service serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,Name,InventoryIDs,LaborCost,Status")
+*/
+std::string Service::getHeaders()
+{
+    return "ID,Name,InventoryIDs,LaborCost,Status";
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/Service.h

@@ -6,6 +6,7 @@ Author: Trenser
 Date: 19-May-2026
 */
 
+
 #pragma once
 #include <string>
 #include "Map.h"
@@ -13,7 +14,6 @@ Date: 19-May-2026
 #include "Enums.h"
 
 class InventoryItem;
-struct SerializedService;
 
 class Service
 {
@@ -40,6 +40,7 @@ public:
     void setRequiredInventoryItems(const util::Map<std::string, InventoryItem*>& requiredInventoryItems);
     void setLaborCost(double laborCost);
     void setState(util::State status);
-    SerializedService serialize() const;
+    std::string serialize() const;
-    static Service* deserialize(const SerializedService&);
+    static Service* deserialize(const std::string&);
+    static std::string getHeaders();
 };

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/ServiceBooking.cpp

@@ -6,10 +6,8 @@ Description: Implementation file containing the method definitions of the
 Author: Trenser
 Date:19-May-2026
 */
-
 #include <stdexcept>
 #include <sstream>
-#include "SerializedRecords.h"
 #include "ServiceBooking.h"
 #include "Service.h"
 #include "Enums.h"
@@ -30,8 +28,7 @@ ServiceBooking::ServiceBooking()
     m_customer(nullptr),
     m_assignedTechnician(nullptr),
     m_status(util::ServiceJobStatus::PENDING),
-    m_discountPercentage(0.0) {
+    m_discountPercentage(0.0) {}
-}
 
 /*
 Function: ServiceBooking
@@ -440,46 +437,84 @@ static util::Vector<std::string> getServiceIDsAsVector(const std::string& servic
 
 /*
 Function: serialize
-Description: Serializes the ServiceBooking object into a SerializedServiceBooking record.
+Description: Serializes the service booking into a CSV-formatted string.
 Parameters:
     - None
 Returns:
-    - SerializedServiceBooking: Serialized representation of the service booking
+    - std::string: Serialized booking record
 */
-SerializedServiceBooking ServiceBooking::serialize() const
+std::string ServiceBooking::serialize() const
 {
-    SerializedServiceBooking serialized = {};
+    std::ostringstream serializedBooking;
-    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
+    serializedBooking << m_id << ','
-    strcpy_s(serialized.serviceIDs, sizeof(serialized.serviceIDs), getServiceIDsAsString(m_serviceIDs).c_str());
+        << util::getServiceJobStatusString(m_status) << ','
-    strcpy_s(serialized.customerId, sizeof(serialized.customerId), m_customerId.c_str());
+        << getServiceIDsAsString(m_serviceIDs) << ','
-    strcpy_s(serialized.vehicleNumber, sizeof(serialized.vehicleNumber), m_vehicleNumber.c_str());
+        << m_customerId << ','
-    strcpy_s(serialized.vehicleBrand, sizeof(serialized.vehicleBrand), m_vehicleBrand.c_str());
+        << m_vehicleNumber << ','
-    strcpy_s(serialized.vehicleModel, sizeof(serialized.vehicleModel), m_vehicleModel.c_str());
+        << m_vehicleBrand << ','
-    strcpy_s(serialized.assignedTechnicianId, sizeof(serialized.assignedTechnicianId), m_assignedTechnicianId.c_str());
+        << m_vehicleModel << ','
-    serialized.status = m_status;
+        << m_assignedTechnicianId << ','
-    serialized.discountPercentage = m_discountPercentage;
+        << m_discountPercentage << ',';
-    return serialized;
+    return serializedBooking.str();
 }
 
 /*
 Function: deserialize
-Description: Deserializes a SerializedServiceBooking record into a ServiceBooking object.
+Description: Deserializes a CSV-formatted string into a ServiceBooking object.
 Parameters:
-    - serializedServiceBooking: const SerializedServiceBooking&, serialized service booking record
+    - record: const std::string&, serialized booking record
 Returns:
     - ServiceBooking*: Pointer to the deserialized ServiceBooking object
+Throws:
+    - std::runtime_error if discount percentage parsing fails
 */
-ServiceBooking* ServiceBooking::deserialize(const SerializedServiceBooking& serializedServiceBooking)
+ServiceBooking* ServiceBooking::deserialize(const std::string& record)
 {
-    util::Vector<std::string> serviceIDs = getServiceIDsAsVector(serializedServiceBooking.serviceIDs);
+    std::string id, customerId, vehicleNumber, vehicleBrand, vehicleModel, assignedTechnicianId;
+    std::string serviceJobStatusString, serviceIDsString, discountPercentageString;
+    double discountPercentage;
+    std::istringstream serializedBooking(record);
+    getline(serializedBooking, id, ',');
+    getline(serializedBooking, serviceJobStatusString, ',');
+    getline(serializedBooking, serviceIDsString, ',');
+    getline(serializedBooking, customerId, ',');
+    getline(serializedBooking, vehicleNumber, ',');
+    getline(serializedBooking, vehicleBrand, ',');
+    getline(serializedBooking, vehicleModel, ',');
+    getline(serializedBooking, assignedTechnicianId, ',');
+    getline(serializedBooking, discountPercentageString, ',');
+    util::Vector<std::string> serviceIDs = getServiceIDsAsVector(serviceIDsString);
+    try
+    {
+        discountPercentage = std::stod(discountPercentageString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid discount percentage");
+    }
+    util::ServiceJobStatus status = util::getServiceJobStatus(serviceJobStatusString);
     return Factory::getObject<ServiceBooking>(
-        serializedServiceBooking.id,
+        id,
-        serializedServiceBooking.status,
+        status,
         serviceIDs,
-        serializedServiceBooking.customerId,
+        customerId,
-        serializedServiceBooking.vehicleNumber,
+        vehicleNumber,
-        serializedServiceBooking.vehicleBrand,
+        vehicleBrand,
-        serializedServiceBooking.vehicleModel,
+        vehicleModel,
-        serializedServiceBooking.assignedTechnicianId,
+        assignedTechnicianId,
-        serializedServiceBooking.discountPercentage);
+        discountPercentage
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for service booking serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,Status,ServiceIDs,CustomerID,VehicleNumber,VehicleBrand,VehicleModel,AssignedTechnicianID,DiscountPercentage")
+*/
+std::string ServiceBooking::getHeaders()
+{
+    return "ID,Status,ServiceIDs,CustomerID,VehicleNumber,VehicleBrand,VehicleModel,AssignedTechnicianID,DiscountPercentage";
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/models/ServiceBooking.h

@@ -6,7 +6,6 @@ Description: Header file declaring the ServiceBooking class, which represents
 Author: Trenser
 Date:19-May-2026
 */
-
 #pragma once
 #include <string>
 #include "Map.h"
@@ -15,7 +14,6 @@ Date:19-May-2026
 
 class Service;
 class User;
-struct SerializedServiceBooking;
 
 class ServiceBooking
 {
@@ -80,6 +78,7 @@ public:
     void setAssignedTechnicianId(const std::string& assignedTechnicianId);
     void setAssignedTechnician(User* assignedTechnician);
     void setDiscountPercentage(double discountPercentage);
-    SerializedServiceBooking serialize() const;
+    std::string serialize() const;
-    static ServiceBooking* deserialize(const SerializedServiceBooking&);
+    static ServiceBooking* 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);
+	util::Map<std::string, User*> users = m_dataStore.getUsers();
-	auto& trackedUserMap = m_dataStore.getUsers();
+	int usersMapSize = users.getSize();
-	int trackedUserMapSize = trackedUserMap.getSize();
+	for (int index = 0; index < usersMapSize; index++)
-	for (int index = 0; index < trackedUserMapSize; 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& inventoryItems = m_dataStore.getInventoryItems();
-	auto& trackedInventoryItemsMap = m_dataStore.getInventoryItems();
+	if (inventoryItems.isEmpty())
-	auto& trackedUserMap = m_dataStore.getUsers();
-	if (trackedInventoryItemsMap.isEmpty())
 	{
 		return;
 	}
-	int inventoryItemsSize = trackedInventoryItemsMap.getSize();
+	int inventoryItemsSize = inventoryItems.getSize();
-	int usersMapSize = trackedUserMap.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.getInventoryItems().insert(newItem->getId(), newItem);
-	m_dataStore.saveInventoryItems();
 }
 
 /*
@@ -120,23 +203,16 @@ Return type: void
 */
 void InventoryManagementService::addInventoryItemStock(const std::string& selectedItemId, int quantity)
 {
-    AuthenticationManagementService::ensureAuthorization();
+    int index = m_dataStore.getInventoryItems().find(selectedItemId);
-	DataStoreLockGuard lock(m_dataStore);
+    if (index != -1)
-	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 = m_dataStore.getInventoryItems().getValueAt(index);
-	}
+        if (item != nullptr)
-	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();
+    }
 }
 
 /*
@@ -147,11 +223,7 @@ Return type: util::Map<std::string, InventoryItem*>
 */
 util::Map<std::string, InventoryItem*> InventoryManagementService::getInventoryItems()
 {
-    AuthenticationManagementService::ensureAuthorization();
+	return m_dataStore.getInventoryItems();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
-	auto inventoryMap = util::getObjects(trackedInventoryItemMap);
-	return inventoryMap;
 }
 
 /*
@@ -162,22 +234,15 @@ Return type: void
 */
 void InventoryManagementService::removeInventoryItem(const std::string& inventoryItemID)
 {
-    AuthenticationManagementService::ensureAuthorization();
+    int index = m_dataStore.getInventoryItems().find(inventoryItemID);
-	DataStoreLockGuard lock(m_dataStore);
+    if (index != -1)
-	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 = m_dataStore.getInventoryItems().getValueAt(index);
-	}
+        if (item != nullptr)
-	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();
+    }
 }
 
 /*
@@ -188,20 +253,12 @@ Return type: InventoryItem*
 */
 InventoryItem* InventoryManagementService::getInventoryItem(const std::string& inventoryItemID)
 {
-    AuthenticationManagementService::ensureAuthorization();
+    int index = m_dataStore.getInventoryItems().find(inventoryItemID);
-	DataStoreLockGuard lock(m_dataStore);
+    if (index != -1)
-	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
-    int index = trackedInventoryItemMap.find(inventoryItemID);
-    if (index == -1)
     {
+        return m_dataStore.getInventoryItems().getValueAt(index);
+    }
     return nullptr;
-    }
-	InventoryItem* inventoryItem = trackedInventoryItemMap.getValueAt(index).data;
-	if (inventoryItem == nullptr)
-	{
-		throw std::runtime_error("Item ID does not exist.");
-	}
-	return inventoryItem;
 }
 
 /*
@@ -276,7 +333,6 @@ void InventoryManagementService::sendNotification(User* user, const std::string&
 	{
 		return;
 	}
-	auto& trackedNotificationsMap = m_dataStore.getNotifications();
 	Notification* notification = Factory::getObject<Notification>(
 		user->getId(),
 		title,
@@ -286,8 +342,8 @@ void InventoryManagementService::sendNotification(User* user, const std::string&
 	{
 		throw std::runtime_error("Failed to create notification");
 	}
+	auto& trackedNotificationsMap = m_dataStore.getNotifications();
 	trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
 	m_dataStore.saveNotifications();
-	EventManager::sendNotificationAvailableEvent(user->getId());
 }
 

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/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.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,17 @@ 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{};
 
@@ -99,7 +97,6 @@ void PaymentManagementService::sendNotification(User* user, const std::string& t
 	{
 		return;
 	}
-	auto& trackedNotificationsMap = m_dataStore.getNotifications();
 	Notification* notification = Factory::getObject<Notification>(
 		user->getId(),
 		title,
@@ -109,9 +106,9 @@ void PaymentManagementService::sendNotification(User* user, const std::string& t
 	{
 		throw std::runtime_error("Failed to create notification");
 	}
+	auto& trackedNotificationsMap = m_dataStore.getNotifications();
 	trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
 	m_dataStore.saveNotifications();
-	EventManager::sendNotificationAvailableEvent(user->getId());
 }
 
 /*
@@ -125,12 +122,11 @@ Returns:
 */
 void PaymentManagementService::sendPaymentReminders()
 {
-	DataStoreLockGuard lock(m_dataStore);
+	auto& invoicesMap = m_dataStore.getInvoices();
-	auto& trackedInvoicesMap = m_dataStore.getInvoices();
+	int invoicesMapSize = invoicesMap.getSize();
-	int invoicesMapSize = trackedInvoicesMap.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 +149,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 +299,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 +308,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();
+	util::Map<std::string, JobCard*> currentJobCards = m_dataStore.getJobCards();
-	for (int iterator = 0; iterator < currentTrackedJobCards.getSize(); iterator++)
+	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 +331,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();
+	util::Map<std::string, Invoice*>& currentInvoices = m_dataStore.getInvoices();
-	currentTrackedInvoices.insert(invoice->getId(), util::createNewRecord(invoice));
+	currentInvoices.insert(invoice->getId(), invoice);
-	m_dataStore.saveInvoices();
 }
 
 /*
@@ -234,13 +345,11 @@ Returns:
 */
 util::Map<std::string, Invoice*> PaymentManagementService::getInvoices(const std::string& customerID)
 {
-    AuthenticationManagementService::ensureAuthorization();
+	util::Map<std::string, Invoice*>& currentInvoices = m_dataStore.getInvoices();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& currentTrackedInvoices = 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 +372,11 @@ Throws:
 */
 void PaymentManagementService::completePayment(const std::string& invoiceID, util::PaymentMode paymentMode)
 {
-    AuthenticationManagementService::ensureAuthorization();
+	auto& currentInvoices = m_dataStore.getInvoices();
-	DataStoreLockGuard lock(m_dataStore);
+	int invoiceIndex = currentInvoices.find(invoiceID);
-	auto& currentTrackedInvoices = m_dataStore.getInvoices();
-	int invoiceIndex = currentTrackedInvoices.find(invoiceID);
 	if (invoiceIndex != -1)
 	{
-		auto& trackedInvoice = currentTrackedInvoices.getValueAt(invoiceIndex);
+		Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
-		Invoice* invoice = trackedInvoice.data;
 		if (invoice && invoice->getStatus() != util::PaymentStatus::PAID)
 		{
 			User* currentUser = invoice->getBooking()->getCustomer();
@@ -281,31 +387,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();
+	return m_dataStore.getInvoices();
-	DataStoreLockGuard lock(m_dataStore);
-	util::Map<std::string, Invoice*> invoices;
-	invoices = util::getObjects(m_dataStore.getInvoices());
-	return invoices;
 }
 
 /*
@@ -321,25 +421,20 @@ Throws:
 */
 void PaymentManagementService::confirmPayment(const std::string& invoiceID)
 {
-    AuthenticationManagementService::ensureAuthorization();
+	auto& currentInvoices = m_dataStore.getInvoices();
-	DataStoreLockGuard lock(m_dataStore);
+	int invoiceIndex = currentInvoices.find(invoiceID);
-	auto& currentTrackedInvoices = m_dataStore.getInvoices();
-	int invoiceIndex = currentTrackedInvoices.find(invoiceID);
 	if (invoiceIndex == -1)
 	{
 		throw std::runtime_error("Payment confirmation failed: invalid invoice ID.");
 	}
-	auto& trackedInvoice = currentTrackedInvoices.getValueAt(invoiceIndex);
+	Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
-	Invoice* invoice = trackedInvoice.data;
 	if (!invoice || invoice->getStatus() != util::PaymentStatus::PAID)
 	{
 		throw std::runtime_error("Payment confirmation failed: invoice is not awaiting confirmation.");
 	}
 	User* currentUser = invoice->getBooking()->getCustomer();
 	invoice->setStatus(util::PaymentStatus::COMPLETED);
-	trackedInvoice.state = RecordState::MODIFIED;
 	std::string title = "Payment Confirmed";
 	std::string message = "Payment Confirmed for Invoice ID " + invoiceID;
 	sendNotification(currentUser, title, message);
-	m_dataStore.saveInvoices();
 }

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

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

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

@@ -11,11 +11,11 @@ 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"
@@ -23,7 +23,6 @@ Date:19-May-2026
 #include "Utility.h"
 #include "TrackedRecord.h"
 #include "DataStoreLockGuard.h"
-#include "EventManager.h"
 
 /*
 Function: ensureAdminExists
@@ -115,7 +114,6 @@ Return type: void
 */
 void UserManagementService::updateUserDetails(const std::string& userID, const std::string& email, const std::string& phone)
 {
-    AuthenticationManagementService::ensureAuthorization();
 	DataStoreLockGuard lock(m_dataStore);
 	auto& trackedUsersMap = m_dataStore.getUsers();
 	auto usersMap = util::getObjects(trackedUsersMap);
@@ -163,7 +161,6 @@ Throws:
 */
 util::Vector<Notification*> UserManagementService::getUserNotifications(const std::string& userID)
 {
-    AuthenticationManagementService::ensureAuthorization();
 	DataStoreLockGuard lock(m_dataStore);
 	auto& trackedUsersMap = m_dataStore.getUsers(); 
 	if (trackedUsersMap.find(userID) == -1)
@@ -184,6 +181,7 @@ util::Vector<Notification*> UserManagementService::getUserNotifications(const st
 				notificationsVector.push_back(notification);
 			}
 		}
+		m_dataStore.unlockDataStore();
 		return notificationsVector;
 	}
 	else
@@ -207,7 +205,6 @@ Throws:
 */
 void UserManagementService::deleteNotification(const std::string& notificationID, const std::string& userID)
 {
-    AuthenticationManagementService::ensureAuthorization();
 	DataStoreLockGuard lock(m_dataStore);
 	auto& trackedUsersMap = m_dataStore.getUsers();
 	auto& trackedNotificationsMap = m_dataStore.getNotifications();
@@ -216,18 +213,15 @@ void UserManagementService::deleteNotification(const std::string& notificationID
 	{
 		throw std::runtime_error("No user found with given UserID");
 	}
+	User* user = trackedUsersMap.getValueAt(userIndex).data;
 	int notificationIndex = trackedNotificationsMap.find(notificationID);
 	if (notificationIndex == -1)
 	{
 		throw std::runtime_error("No notification found with given NotificationID");
 	}
-	Notification* notification = trackedNotificationsMap.getValueAt(notificationIndex).data;
+	trackedNotificationsMap.getValueAt(notificationIndex).data->setState(util::State::INACTIVE);
-	if (notification->getRecipientUserId() == userID)
-	{
-		notification->setState(util::State::INACTIVE);
 	trackedNotificationsMap.getValueAt(notificationIndex).state = RecordState::MODIFIED;
 	m_dataStore.saveNotifications();
-	}
 }
 
 /*
@@ -269,12 +263,9 @@ Return type: void
 */
 void UserManagementService::removeUser(const std::string& userID)
 {
-    AuthenticationManagementService::ensureAuthorization();
 	InventoryManagementService inventoryManagementService;
 	PaymentManagementService paymentManagementService;
 	ServiceManagementService serviceManagementService;
-	std::string removedUserID;
-	{
 	DataStoreLockGuard lock(m_dataStore);
 	auto& trackedUsersMap = m_dataStore.getUsers();
 	int index = trackedUsersMap.find(userID);
@@ -296,15 +287,9 @@ void UserManagementService::removeUser(const std::string& userID)
 			serviceManagementService.detach(user);
 			user->setState(util::State::INACTIVE);
 			trackedUsersMap.getValueAt(index).state = RecordState::MODIFIED;
-				removedUserID = user->getId();
 			m_dataStore.saveUsers();
 		}
 	}
-	}
-	if (!removedUserID.empty())
-	{
-		EventManager::sendUserDisabledEvent(removedUserID);
-	}
 }
 
 /*

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

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"
+                << "\n6. Complete Payments"
-                << "\n7. Complete Payments"
+                << "\n7. View Invoices"
-                << "\n8. View Invoices"
+                << "\n8. View Notifications"
-                << "\n9. View Notifications"
+                << "\n9. Configure Notifications"
-                << "\n10. Configure Notifications"
+                << "\n10. Logout"
-                << "\n11. 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,9 +1130,7 @@ 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;
         }
@@ -1156,7 +1140,6 @@ inline void displayAllComboPackages(util::Map<std::string, const ComboPackage*>
             << std::setw(15) << util::calculateComboServiceEstimatedCost(currentComboPackage)
             << std::endl;
     }
-    }
 }
 
 
@@ -1181,9 +1164,7 @@ 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;
         }
@@ -1196,7 +1177,6 @@ inline const ComboPackage* selectComboPackageFromPackages(const util::Map<std::s
             << std::endl;
         currentIndex++;
     }
-    }
     if (activeComboPackages.getSize() == 0)
     {
         std::cout << "No active combo packages available." << std::endl;
@@ -1428,88 +1408,3 @@ inline std::string selectComboPackage(util::Map<std::string, const ComboPackage*
         return "";
     }
 }
-
-/*
-Function: displayNewNotification
-Description: Displays the most recent notification from the supplied
-             notification collection.
-Parameter: util::Vector<const Notification*> notifications -
-           collection of notifications
-           const std::string& - The name of the user currently authenticated with the system
-Return type: void
-*/
-inline void displayNewNotification(util::Vector<const Notification*> notifications, const std::string& name)
-{
-    const Notification* notification = nullptr;
-	size_t numberOfNotifications = notifications.getSize();
-	for (int index = 0; index < numberOfNotifications; index++)
-	{
-		if (!notification)
-		{
-			notification = notifications[index];
-		}
-		else
-		{
-            if (util::extractNumber(notification->getId()) < util::extractNumber(notifications[index]->getId()))
-			{
-				notification = notifications[index];
-			}
-		}
-	}
-    if (notification)
-    {
-        std::string messageTitle = notification->getTitle();
-        if (!name.empty())
-        {
-            messageTitle += " - " + name;
-        }
-        MessageBoxA(
-            GetConsoleWindow(),
-            notification->getMessage().c_str(),
-            messageTitle.c_str(),
-            MB_OK |
-            MB_ICONINFORMATION);
-    }
-}
-
-/*
-Function: verifyAllPaymentsCompleted
-Description: Checks whether the authenticated customer has completed
-             all payments for their invoices. Iterates through all
-             invoices belonging to the customer and verifies that
-             each invoice has a payment status of COMPLETED.
-Parameters: Controller& m_controller -
-            reference to the Controller object used to access
-            authenticated user and invoice data
-Return type: bool
-             true if all invoices for the authenticated customer
-             are completed, false if any invoice is pending or not completed
-Throws: std::runtime_error if no authenticated user is found
-*/
-inline bool verifyAllPaymentsCompleted(Controller& m_controller)
-{
-    const User* authenticatedUser = m_controller.getAuthenticatedUser();
-    if (!authenticatedUser)
-    {
-        throw std::runtime_error("No authenticated user found.");
-    }
-    const std::string& authenticatedUserId = authenticatedUser->getId();
-    util::Map<std::string, const Invoice*> listOfInvoices = m_controller.getAllInvoices();
-    for (int invoiceIndex = 0; invoiceIndex < listOfInvoices.getSize(); ++invoiceIndex)
-    {
-        const Invoice* invoice = listOfInvoices.getValueAt(invoiceIndex);
-        if (!invoice)
-        {
-            continue;
-        }
-        const std::string& customerId = invoice->getBooking()->getCustomerId();
-        if (customerId == authenticatedUserId)
-        {
-            if (invoice->getStatus() != util::PaymentStatus::COMPLETED)
-            {
-                return false;
-            }
-        }
-    }
-    return true;
-}

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