Merge branch 'develop' into develop-sm-service-management

User Story #1951
User Story #1952
**Changes**
- Added DataStoreLockGuard for scoped locking/unlocking.
- Applied lock guard in AuthenticationManagementService (login, password change).
- Switched User serialization from CSV to SerializedUser struct.
- Removed old CSV-based serialize, deserialize, and getHeaders.
- Updated DataStore::getUsers to refresh cache and attach notifications.
- Enhanced DataStore::saveUsers to persist users and notifications.
- Marked modified records in changePassword and saved changes.
- Included DataStoreLockGuard.h in project files.
- Improved error handling for invalid user IDs and missing users.

Related work items: #1929, #1951, #1952

.gitignore

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

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;%(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;%(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>
@@ -129,6 +129,7 @@
     <ClCompile Include="core\patterns\Observer.cpp" />
     <ClCompile Include="core\patterns\Subject.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" />
@@ -139,7 +140,6 @@
     <ClCompile Include="models\User.cpp" />
     <ClCompile Include="services\AuthenticationManagementService.cpp" />
     <ClCompile Include="services\InventoryManagementService.cpp" />
-    <ClCompile Include="services\NotificationManagementService.cpp" />
     <ClCompile Include="services\PaymentManagementService.cpp" />
     <ClCompile Include="services\ServiceManagementService.cpp" />
     <ClCompile Include="services\UserManagementService.cpp" />
@@ -156,6 +156,13 @@
     <ClInclude Include="core\patterns\Observer.h" />
     <ClInclude Include="core\patterns\Subject.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" />
@@ -174,7 +181,6 @@
     <ClInclude Include="utilities\Config.h" />
     <ClInclude Include="utilities\Enums.h" />
     <ClInclude Include="utilities\FileHelper.h" />
-    <ClInclude Include="utilities\FileManager.h" />
     <ClInclude Include="utilities\InputHelper.h" />
     <ClInclude Include="utilities\Map.h" />
     <ClInclude Include="utilities\OutputHelper.h" />

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

@@ -64,6 +64,12 @@
     <Filter Include="Source Files\Core\Patterns">
       <UniqueIdentifier>{8057b93d-51a9-42df-b06e-01ce395f6308}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Header Files\DataStores\SharedMemory">
+      <UniqueIdentifier>{ec639004-44c6-4bd6-9963-077adde82b5f}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\DataStores\SharedMemory">
+      <UniqueIdentifier>{7aa8722e-adfa-466e-8211-de63f3b7892b}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Trenser.VehicleServiceSystem.cpp">
@@ -108,9 +114,6 @@
     <ClCompile Include="datastores\DataStore.cpp">
       <Filter>Source Files\DataStores</Filter>
     </ClCompile>
-    <ClCompile Include="services\NotificationManagementService.cpp">
-      <Filter>Source Files\Services</Filter>
-    </ClCompile>
     <ClCompile Include="core\patterns\Observer.cpp">
       <Filter>Source Files\Core\Patterns</Filter>
     </ClCompile>
@@ -141,6 +144,9 @@
     <ClCompile Include="models\ComboPackage.cpp">
       <Filter>Source Files\Models</Filter>
     </ClCompile>
+    <ClCompile Include="datastores\sharedmemory\SharedMemory.cpp">
+      <Filter>Source Files\DataStores\SharedMemory</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="utilities\InputHelper.h">
@@ -236,9 +242,6 @@
     <ClInclude Include="utilities\Config.h">
       <Filter>Header Files\Utilities</Filter>
     </ClInclude>
-    <ClInclude Include="utilities\FileManager.h">
-      <Filter>Header Files\Utilities</Filter>
-    </ClInclude>
     <ClInclude Include="utilities\StringHelper.h">
       <Filter>Header Files\Utilities</Filter>
     </ClInclude>
@@ -251,5 +254,26 @@
     <ClInclude Include="views\MenuHelper.h">
       <Filter>Header Files\Views</Filter>
     </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\FileHeader.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\MappingInfo.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\RecordState.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\TrackedRecord.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\SerializedRecords.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\SharedMemory.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\DataStoreLockGuard.h">
+      <Filter>Header Files\DataStores</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

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

@@ -6,6 +6,7 @@ Description: Implementation file containing the method definitions of the
 Author: Trenser
 Date:19-May-2026
 */
+
 #include "ComboPackage.h"
 #include "Controller.h"
 #include "Enums.h"
@@ -392,9 +393,9 @@ Parameters:
 Returns:
     - void
 */
-void Controller::completeJob(const std::string& jobID)
+void Controller::updateJobStatus(const std::string& jobID)
 {
-    m_serviceManagementService.completeJob(jobID);
+    m_serviceManagementService.updateJobStatus(jobID);
 }
 
 /*
@@ -462,6 +463,38 @@ util::Map<std::string, const Invoice*> Controller::getInvoicesByUser()
     return userInvoicesReadOnly;
 }
 
+/*
+Function: getAllInvoices
+Description: Retrieves all invoices from the PaymentManagementService and returns them as a read-only map.
+Parameters:
+    - none
+Returns:
+    - util::Map<std::string, const Invoice*>: Map of invoice IDs to invoice objects
+*/
+util::Map<std::string, const Invoice*> Controller::getAllInvoices()
+{
+    auto invoices = m_paymentManagementService.getAllInvoices();
+    util::Map<std::string, const Invoice*> readOnlyInvoice;
+    for (int iterator = 0; iterator < invoices.getSize(); iterator++)
+    {
+        readOnlyInvoice.insert(invoices.getKeyAt(iterator), invoices.getValueAt(iterator));
+    }
+    return readOnlyInvoice;
+}
+
+/*
+Function: confirmPayment
+Description: Delegates payment confirmation for a given invoice ID to the PaymentManagementService.
+Parameters:
+    - invoiceID: std::string, ID of the invoice to confirm
+Returns:
+    - void
+*/
+void Controller::confirmPayment(const std::string& invoiceID)
+{
+    m_paymentManagementService.confirmPayment(invoiceID);
+}
+
 /*
 Function: completePayment
 Description: Completes payment for a specific invoice using the given payment mode.
@@ -555,63 +588,37 @@ void Controller::configureNotifications(bool paymentNotifications, bool serviceN
 }
 
 /*
-Function: loadSystemData
-Description: Loads all system data from persistent storage into memory.
-             Invokes the respective management services to load users, inventory items, services,
-             combo packages, service bookings, job cards, invoices, and observers.
+Function: initialize
+Description: Initializes the system and run system checks to ensure critical configurations, such as verifying admin existence.
 Parameters:
     - None
 Returns:
-    - void
+    - bool
 */
-void Controller::loadSystemData()
+bool Controller::initialize()
 {
-    m_userManagementService.loadUsers();
-    m_inventoryManagementService.loadInventoryItems();
-    m_serviceManagementService.loadServices();
-    m_serviceManagementService.loadComboPackages();
-    m_serviceManagementService.loadServiceBookings();
-    m_serviceManagementService.loadJobCards();
-    m_paymentManagementService.loadInvoices();
-    m_serviceManagementService.loadObservers();
-    m_paymentManagementService.loadObservers();
-    m_inventoryManagementService.loadObservers();
-}
+    auto& dataStore = DataStore::getInstance();
 
-/*
-Function: saveSystemData
-Description: Saves all system data from memory back to persistent storage.
-             Invokes the respective management services to save users, inventory items, services,
-             combo packages, service bookings, job cards, invoices, and observers.
-Parameters:
-    - None
-Returns:
-    - void
-*/
-void Controller::saveSystemData()
-{
-    m_userManagementService.saveUsers();
-    m_inventoryManagementService.saveInventoryItems();
-    m_serviceManagementService.saveServices();
-    m_serviceManagementService.saveComboPackages();
-    m_serviceManagementService.saveServiceBookings();
-    m_serviceManagementService.saveJobCards();
-    m_paymentManagementService.saveInvoices();
-    m_serviceManagementService.saveObservers();
-    m_paymentManagementService.saveObservers();
-    m_inventoryManagementService.saveObservers();
-}
-
-/*
-Function: runSystemChecks
-Description: Runs system checks to ensure critical configurations, such as verifying admin existence.
-Parameter: None
-Return type: void
-*/
-void Controller::runSystemChecks()
-{
+    if (!dataStore.initialize())
+    {
+        return false;
+    }
     m_userManagementService.ensureAdminExists();
     m_inventoryManagementService.sendLowStockAlerts();
     m_paymentManagementService.sendPaymentReminders();
+    return true;
 }
 
+/*
+Function: shutdown
+Description: Shutdown the system, and do necessary cleanups
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void Controller::shutdown()
+{
+    auto& dataStore = DataStore::getInstance();
+    dataStore.shutdown();
+}

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

@@ -59,16 +59,17 @@ public:
     void createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost);
     void removeService(const std::string& serviceID);
     util::Map<std::string, const JobCard*> getJobCardsByUser();
-    void completeJob(const std::string& jobID);
+    void updateJobStatus(const std::string& jobID);
     void removeUser(const std::string& userID);
     void createComboPackage(const std::string& name, const util::Vector<std::string>& serviceIDs, double discountPercentage);
     void removeComboPackage(const std::string& comboPackageID);
     util::Map<std::string, const Invoice*> getInvoicesByUser();
+    util::Map<std::string, const Invoice*> getAllInvoices();
+    void confirmPayment(const std::string& invoiceID);
     void completePayment(const std::string& invoiceID, util::PaymentMode paymentMode);
     util::Vector<const Notification*> getNotifications();
     void deleteNotification(const std::string& notificationID);
     void configureNotifications(bool paymentNotifications, bool serviceNotifications);
-    void loadSystemData();
-    void saveSystemData();
-    void runSystemChecks();
+    bool initialize();
+    void shutdown();
 };

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

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

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

@@ -9,6 +9,196 @@ Date: 19-May-2026
 */
 
 #include "DataStore.h"
+#include "Config.h"
+#include "SerializedRecords.h"
+#include "FileHelper.h"
+#include "ServiceBooking.h"
+#include "JobCard.h"
+
+/*
+Function: DataStore
+Description: Constructs the DataStore singleton and initializes
+             internal handles to their default values.
+Parameters:
+    - None
+Returns:
+    - None
+*/
+DataStore::DataStore() :
+    m_globalMutex(NULL) {}
+
+/*
+Function: ~DataStore
+Description: Destroys the DataStore singleton and releases all
+             cached application objects owned by the datastore.
+             This includes users, notifications, services,
+             combo packages, inventory items, service bookings,
+             job cards, and invoices.
+Parameters:
+    - None
+Returns:
+    - None
+*/
+DataStore::~DataStore()
+{
+    clearCache(m_userCache);
+    clearCache(m_notificationCache);
+    clearCache(m_serviceCache);
+    clearCache(m_comboPackageCache);
+    clearCache(m_inventoryItemCache);
+    clearCache(m_serviceBookingCache);
+    clearCache(m_jobCardCache);
+    clearCache(m_invoiceCache);
+}
+
+/*
+Function: initialize
+Description: Initializes the shared-memory datastore.
+             Creates or opens the global datastore mutex,
+             configures all mapping metadata, and creates
+             or opens the file mappings used to persist
+             application data. After successful completion,
+             all datastore files are mapped into memory and
+             ready for use by the application.
+Parameter: None
+Return type: bool
+             - true  : Initialization completed successfully.
+             - false : Failed to create the mutex or open
+                       one or more file mappings.
+*/
+bool DataStore::initialize()
+{
+    m_globalMutex = CreateMutexA(NULL, FALSE, "VehicleServiceSystemMutex");
+    if (m_globalMutex == NULL)
+    {
+        return false;
+    }
+    if (!lockDataStore())
+    {
+        CloseHandle(m_globalMutex);
+        m_globalMutex = NULL;
+        return false;
+    }
+    bool success = true;
+    do
+    {
+        util::ensureDirectoryExists(config::file::DIRECTORY);
+        m_users.fileName = config::file::USER_FILE;
+        m_users.recordSize = sizeof(SerializedUser);
+        m_notifications.fileName = config::file::NOTIFICATION_FILE;
+        m_notifications.recordSize = sizeof(SerializedNotification);
+        m_services.fileName = config::file::SERVICE_FILE;
+        m_services.recordSize = sizeof(SerializedService);
+        m_comboPackages.fileName = config::file::COMBOPACKAGE_FILE;
+        m_comboPackages.recordSize = sizeof(SerializedComboPackage);
+        m_inventoryItems.fileName = config::file::INVENTORYITEM_FILE;
+        m_inventoryItems.recordSize = sizeof(SerializedInventoryItem);
+        m_serviceBookings.fileName = config::file::SERVICEBOOKING_FILE;
+        m_serviceBookings.recordSize = sizeof(SerializedServiceBooking);
+        m_jobCards.fileName = config::file::JOBCARD_FILE;
+        m_jobCards.recordSize = sizeof(SerializedJobCard);
+        m_invoices.fileName = config::file::INVOICE_FILE;
+        m_invoices.recordSize = sizeof(SerializedInvoice);
+        m_serviceManagementObservers.fileName = config::file::SERVICEMANAGEMENTOBSERVERS;
+        m_serviceManagementObservers.recordSize = sizeof(SerializedObserver);
+        m_paymentManagementObservers.fileName = config::file::PAYMENTMANAGEMENTOBSERVERS;
+        m_paymentManagementObservers.recordSize = sizeof(SerializedObserver);
+        m_inventoryManagementObservers.fileName = config::file::INVENTORYMANAGEMENTOBSERVERS;
+        m_inventoryManagementObservers.recordSize = sizeof(SerializedObserver);
+        if (!SharedMemory::createOrOpenMapping(m_users))
+        {
+            success = false;
+            break;
+        }
+        if (!SharedMemory::createOrOpenMapping(m_notifications))
+        {
+            success = false;
+            break;
+        }
+        if (!SharedMemory::createOrOpenMapping(m_services))
+        {
+            success = false;
+            break;
+        }
+
+        if (!SharedMemory::createOrOpenMapping(m_comboPackages))
+        {
+            success = false;
+            break;
+        }
+        if (!SharedMemory::createOrOpenMapping(m_inventoryItems))
+        {
+            success = false;
+            break;
+        }
+        if (!SharedMemory::createOrOpenMapping(m_serviceBookings))
+        {
+            success = false;
+            break;
+        }
+        if (!SharedMemory::createOrOpenMapping(m_jobCards))
+        {
+            success = false;
+            break;
+        }
+        if (!SharedMemory::createOrOpenMapping(m_invoices))
+        {
+            success = false;
+            break;
+        }
+        if (!SharedMemory::createOrOpenMapping(m_serviceManagementObservers))
+        {
+            success = false;
+            break;
+        }
+        if (!SharedMemory::createOrOpenMapping(m_paymentManagementObservers))
+        {
+            success = false;
+            break;
+        }
+        if (!SharedMemory::createOrOpenMapping(m_inventoryManagementObservers))
+        {
+            success = false;
+            break;
+        }
+    } while (false);
+    unlockDataStore();
+    if (!success)
+    {
+        shutdown();
+    }
+    return success;
+}
+
+/*
+Function: shutdown
+Description: Releases all shared-memory resources owned by the
+             datastore. Closes every file mapping, unmaps all
+             mapped views, and releases the datastore mutex.
+             After this call, the datastore must be initialized
+             again before use.
+Parameter: None
+Return type: void
+*/
+void DataStore::shutdown()
+{
+    SharedMemory::closeMapping(m_users);
+    SharedMemory::closeMapping(m_notifications);
+    SharedMemory::closeMapping(m_services);
+    SharedMemory::closeMapping(m_comboPackages);
+    SharedMemory::closeMapping(m_inventoryItems);
+    SharedMemory::closeMapping(m_serviceBookings);
+    SharedMemory::closeMapping(m_jobCards);
+    SharedMemory::closeMapping(m_invoices);
+    SharedMemory::closeMapping(m_serviceManagementObservers);
+    SharedMemory::closeMapping(m_paymentManagementObservers);
+    SharedMemory::closeMapping(m_inventoryManagementObservers);
+    if (m_globalMutex != NULL)
+    {
+        CloseHandle(m_globalMutex);
+        m_globalMutex = NULL;
+    }
+}
 
 /*
 Function: getInstance
@@ -26,104 +216,525 @@ DataStore& DataStore::getInstance()
 
 /*
 Function: getUsers
-Description: Retrieves the internal map of users.
+Description: Retrieves all user records from the datastore.
 Parameters:
     - None
 Returns:
-    - Reference to util::Map<std::string, User*> containing all users.
+    - util::Map<std::string, TrackedRecord<User>>: Collection of user records
 */
-util::Map<std::string, User*>& DataStore::getUsers()
+util::Map<std::string, TrackedRecord<User>>& DataStore::getUsers()
 {
-    return m_users;
+    auto users = loadRecords<User, SerializedUser>(m_users);
+    refreshCache(m_userCache, users);
+    return m_userCache;
+}
+
+/*
+Function: getNotifications
+Description: Retrieves all notification records from the datastore.
+Parameters:
+    - None
+Returns:
+    - util::Map<std::string, TrackedRecord<Notification>>: Collection of notification records
+*/
+util::Map<std::string, TrackedRecord<Notification>>& DataStore::getNotifications()
+{
+    auto notifications = loadRecords<Notification, SerializedNotification>(m_notifications);
+    refreshCache(m_notificationCache, notifications);
+    return m_notificationCache;
 }
 
 /*
 Function: getServices
-Description: Retrieves the internal map of services.
+Description: Retrieves all service records from the datastore.
 Parameters:
     - None
 Returns:
-    - Reference to util::Map<std::string, Service*> containing all services.
+    - util::Map<std::string, TrackedRecord<Service>>: Collection of service records
 */
-util::Map<std::string, Service*>& DataStore::getServices()
+util::Map<std::string, TrackedRecord<Service>>& DataStore::getServices()
 {
-    return m_services;
+    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;
 }
 
 /*
 Function: getComboPackages
-Description: Retrieves the internal map of combo packages.
+Description: Retrieves all combo package records from the datastore.
 Parameters:
     - None
 Returns:
-    - Reference to util::Map<std::string, ComboPackage*> containing all combo packages.
+    - util::Map<std::string, TrackedRecord<ComboPackage>>: Collection of combo package records
 */
-util::Map<std::string, ComboPackage*>& DataStore::getComboPackages()
+util::Map<std::string, TrackedRecord<ComboPackage>>& DataStore::getComboPackages()
 {
-    return m_comboPackages;
-}
-
-/*
-Function: getServiceBookings
-Description: Retrieves the internal map of service bookings.
-Parameters:
-    - None
-Returns:
-    - Reference to util::Map<std::string, ServiceBooking*> containing all service bookings.
-*/
-util::Map<std::string, ServiceBooking*>& DataStore::getServiceBookings()
-{
-    return m_serviceBookings;
-}
-
-/*
-Function: getJobCards
-Description: Retrieves the internal map of job cards.
-Parameters:
-    - None
-Returns:
-    - Reference to util::Map<std::string, JobCard*> containing all job cards.
-*/
-util::Map<std::string, JobCard*>& DataStore::getJobCards()
-{
-    return m_jobCards;
+    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;
 }
 
 /*
 Function: getInventoryItems
-Description: Retrieves the internal map of inventory items.
+Description: Retrieves all inventory item records from the datastore.
 Parameters:
     - None
 Returns:
-    - Reference to util::Map<std::string, InventoryItem*> containing all inventory items.
+    - util::Map<std::string, TrackedRecord<InventoryItem>>: Collection of inventory item records
 */
-util::Map<std::string, InventoryItem*>& DataStore::getInventoryItems()
+util::Map<std::string, TrackedRecord<InventoryItem>>& DataStore::getInventoryItems()
 {
-    return m_inventoryItems;
+    return m_inventoryItemCache;
 }
 
+/*
+Function: getServiceBookings
+Description: Retrieves all service booking records from the datastore.
+Parameters:
+    - None
+Returns:
+    - util::Map<std::string, TrackedRecord<ServiceBooking>>: Collection of service booking records
+*/
+util::Map<std::string, TrackedRecord<ServiceBooking>>& DataStore::getServiceBookings()
+{
+    util::Map<std::string, TrackedRecord<ServiceBooking>> 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;
+}
+
+/*
+Function: getJobCards
+Description: Retrieves all job card records from the datastore.
+Parameters:
+    - None
+Returns:
+    - util::Map<std::string, TrackedRecord<JobCard>>: Collection of job card records
+*/
+util::Map<std::string, TrackedRecord<JobCard>>& DataStore::getJobCards()
+{
+    util::Map<std::string, TrackedRecord<JobCard>> 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 the internal map of invoices.
+Description: Retrieves all invoice records from the datastore.
 Parameters:
     - None
 Returns:
-    - Reference to util::Map<std::string, Invoice*> containing all invoices.
+    - util::Map<std::string, TrackedRecord<Invoice>>: Collection of invoice records
 */
-util::Map<std::string, Invoice*>& DataStore::getInvoices()
+util::Map<std::string, TrackedRecord<Invoice>>& DataStore::getInvoices()
 {
-    return m_invoices;
+    return m_invoiceCache;
 }
 
 /*
-Function: getPayments
-Description: Retrieves the internal map of payments.
+Function: getObservers
+Description: Retrieves observer records from the specified observer mapping
+             and resolves them to User objects.
+Parameters:
+    - mapping: Observer mapping to read from
+Returns:
+    - util::Map<std::string, User*>: Collection of observer records
+Throws:
+    - std::runtime_error if an observer references an invalid user ID
+*/
+util::Map<std::string, User*> DataStore::getObservers(MappingInfo& mapping)
+{
+    auto& users = getUsers();
+    util::Map<std::string, User*> observers;
+    SharedMemory::ensureLatestMapping(mapping);
+    size_t recordCount = SharedMemory::getRecordCount(mapping);
+    for (size_t index = 0; index < recordCount; index++)
+    {
+        const SerializedObserver* observer = static_cast<SerializedObserver*>(SharedMemory::getRecordAddress(mapping, index));
+        int userIndex = users.find(observer->id);
+        if (userIndex == -1)
+        {
+            throw std::runtime_error("Invalid observer user ID");
+        }
+        User* user = users.getValueAt(userIndex).data;
+        observers.insert(user->getId(), user);
+    }
+    return observers;
+}
+
+/*
+Function: getServiceManagementObservers
+Description: Retrieves all service management observer records from the datastore.
 Parameters:
     - None
 Returns:
-    - Reference to util::Map<std::string, Payment*> containing all payments.
+    - util::Map<std::string, User*>: Collection of observer records
 */
-util::Map<std::string, Payment*>& DataStore::getPayments()
+util::Map<std::string, User*> DataStore::getServiceManagementObservers()
 {
-    return m_payments;
-}
+    return getObservers(m_serviceManagementObservers);
+}
+
+/*
+Function: getPaymentManagementObservers
+Description: Retrieves all payment management observer records from the datastore.
+Parameters:
+    - None
+Returns:
+    - util::Map<std::string, User*>: Collection of observer records
+*/
+util::Map<std::string, User*> DataStore::getPaymentManagementObservers()
+{
+    return getObservers(m_paymentManagementObservers);
+}
+
+/*
+Function: getInventoryManagementObservers
+Description: Retrieves all inventory management observer records from the datastore.
+Parameters:
+    - None
+Returns:
+    - util::Map<std::string, User*>: Collection of observer records
+*/
+util::Map<std::string, User*> DataStore::getInventoryManagementObservers()
+{
+    return getObservers(m_inventoryManagementObservers);
+}
+
+/*
+Function: saveUsers
+Description: Persists all user records to the datastore.
+Parameters:
+    - None
+Returns:
+    - None
+*/
+void DataStore::saveUsers()
+{
+    saveRecords<User, SerializedUser>(m_users, m_userCache);
+}
+
+/*
+Function: saveNotifications
+Description: Persists all notification records to the datastore.
+Parameters:
+    - None
+Returns:
+    - None
+*/
+void DataStore::saveNotifications()
+{
+    saveRecords<Notification, SerializedNotification>(m_notifications, m_notificationCache);
+}
+
+/*
+Function: saveServices
+Description: Persists all service records to the datastore.
+Parameters:
+    - None
+Returns:
+    - None
+*/
+void DataStore::saveServices()
+{
+    saveRecords<Service, SerializedService>(m_services, m_serviceCache);
+}
+
+/*
+Function: saveComboPackages
+Description: Persists all combo package records to the datastore.
+Parameters:
+    - None
+Returns:
+    - None
+*/
+void DataStore::saveComboPackages()
+{
+    saveRecords<ComboPackage, SerializedComboPackage>(m_comboPackages, m_comboPackageCache);
+}
+
+/*
+Function: saveInventoryItems
+Description: Persists all inventory item records to the datastore.
+Parameters:
+    - None
+Returns:
+    - None
+*/
+void DataStore::saveInventoryItems()
+{
+}
+
+/*
+Function: saveServiceBookings
+Description: Persists all service booking records to the datastore.
+Parameters:
+    - None
+Returns:
+    - None
+*/
+void DataStore::saveServiceBookings()
+{
+    saveRecords<ServiceBooking, SerializedServiceBooking>(m_serviceBookings, m_serviceBookingCache);
+}
+
+/*
+Function: saveJobCards
+Description: Persists all job card records to the datastore.
+Parameters:
+    - None
+Returns:
+    - None
+*/
+void DataStore::saveJobCards()
+{
+    saveRecords<JobCard, SerializedJobCard>(m_jobCards, m_jobCardCache);
+}
+
+/*
+Function: saveInvoices
+Description: Persists all invoice records to the datastore.
+Parameters:
+    - None
+Returns:
+    - None
+*/
+void DataStore::saveInvoices()
+{
+}
+
+/*
+Function: saveObservers
+Description: Persists observer records to the specified observer mapping.
+Parameters:
+    - mapping: MappingInfo&, observer mapping to save to
+    - observers: util::Map<std::string, User*>&, collection of observer records
+Returns:
+    - None
+*/
+void DataStore::saveObservers(MappingInfo& mapping, util::Map<std::string, User*>& observers)
+{
+    size_t observerCount = static_cast<size_t>(observers.getSize());
+    size_t capacity = config::file::INITIAL_CAPACITY;
+    while (capacity < observerCount)
+    {
+        capacity *= config::file::GROWTH_FACTOR;
+    }
+    if (!SharedMemory::resizeMapping(mapping, capacity))
+    {
+        throw std::runtime_error("Failed to resize observer mapping");
+    }
+    SharedMemory::setRecordCount(mapping, observerCount);
+    for (size_t index = 0; index < observerCount; index++)
+    {
+        SerializedObserver serializedObserver;
+        User* user = observers.getValueAt(static_cast<int>(index));
+        strcpy_s(serializedObserver.id, sizeof(serializedObserver.id), user->getId().c_str());
+        SerializedObserver* destination = static_cast<SerializedObserver*>(SharedMemory::getRecordAddress(mapping, index));
+        *destination = serializedObserver;
+    }
+}
+
+/*
+Function: saveServiceManagementObservers
+Description: Persists all service management observer records to the datastore.
+Parameters:
+    - observers: util::Map<std::string, User*>&, collection of observer records
+Returns:
+    - None
+*/
+void DataStore::saveServiceManagementObservers(util::Map<std::string, User*>& observers)
+{
+    saveObservers(m_serviceManagementObservers, observers);
+}
+
+/*
+Function: savePaymentManagementObservers
+Description: Persists all payment management observer records to the datastore.
+Parameters:
+    - observers: util::Map<std::string, User*>&, collection of observer records
+Returns:
+    - None
+*/
+void DataStore::savePaymentManagementObservers(util::Map<std::string, User*>& observers)
+{
+    saveObservers(m_paymentManagementObservers, observers);
+}
+
+/*
+Function: saveInventoryManagementObservers
+Description: Persists all inventory management observer records to the datastore.
+Parameters:
+    - observers: util::Map<std::string, User*>&, collection of observer records
+Returns:
+    - None
+*/
+void DataStore::saveInventoryManagementObservers(util::Map<std::string, User*>& observers)
+{
+    saveObservers(m_inventoryManagementObservers, observers);
+}
+
+/*
+Function: lockDataStore
+Description: Acquires the datastore mutex, providing
+             exclusive access to the shared-memory
+             datastore. This function blocks until
+             the mutex becomes available or an error
+             occurs.
+Parameter: None
+Return type:
+    bool
+    - true  : Mutex successfully acquired.
+    - false : Failed to acquire the mutex.
+*/
+bool DataStore::lockDataStore()
+{
+    if (m_globalMutex == NULL)
+    {
+        return false;
+    }
+    DWORD result = WaitForSingleObject(m_globalMutex, INFINITE);
+    return result == WAIT_OBJECT_0;
+}
+
+/*
+Function: unlockDataStore
+Description: Releases the datastore mutex after a
+             successful call to lockDataStore(),
+             allowing other processes to access the
+             shared-memory datastore.
+Parameter: None
+Return type:
+    bool
+    - true  : Mutex successfully released.
+    - false : Failed to release the mutex.
+*/
+bool DataStore::unlockDataStore()
+{
+    if (m_globalMutex == NULL)
+    {
+        return false;
+    }
+    return ReleaseMutex(m_globalMutex) != 0;
+}
+

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

@@ -6,42 +6,242 @@ Date: 19-May-2026
 */
 
 #pragma once
+#include <windows.h>
 #include <string>
 #include "Map.h"
-
-class User;
-class Service;
-class ComboPackage;
-class ServiceBooking;
-class JobCard;
-class InventoryItem;
-class Invoice;
-class Payment;
+#include "MappingInfo.h"
+#include "TrackedRecord.h"
+#include "SerializedRecords.h"
+#include "SharedMemory.h"
+#include "User.h"
+#include "Notification.h"
+#include "Service.h"
+#include "ComboPackage.h"
+#include "InventoryItem.h"
+#include "ServiceBooking.h"
+#include "JobCard.h"
+#include "Invoice.h"
 
 class DataStore
 {
 private:
-    util::Map<std::string, User*> m_users;
-    util::Map<std::string, Service*> m_services;
-    util::Map<std::string, ComboPackage*> m_comboPackages;
-    util::Map<std::string, ServiceBooking*> m_serviceBookings;
-    util::Map<std::string, JobCard*> m_jobCards;
-    util::Map<std::string, InventoryItem*> m_inventoryItems;
-    util::Map<std::string, Invoice*> m_invoices;
-    util::Map<std::string, Payment*> m_payments;
-    DataStore() {}
-public:
-    static DataStore& getInstance();
+    DataStore();
+    ~DataStore();
     DataStore(const DataStore&) = delete;
     DataStore& operator=(const DataStore&) = delete;
     DataStore(DataStore&&) = delete;
     DataStore& operator=(DataStore&&) = delete;
-    util::Map<std::string, User*>& getUsers();
-    util::Map<std::string, Service*>& getServices();
-    util::Map<std::string, ComboPackage*>& getComboPackages();
-    util::Map<std::string, ServiceBooking*>& getServiceBookings();
-    util::Map<std::string, JobCard*>& getJobCards();
-    util::Map<std::string, InventoryItem*>& getInventoryItems();
-    util::Map<std::string, Invoice*>& getInvoices();
-    util::Map<std::string, Payment*>& getPayments();
-};
+    HANDLE m_globalMutex;
+    MappingInfo m_users;
+    MappingInfo m_notifications;
+    MappingInfo m_services;
+    MappingInfo m_comboPackages;
+    MappingInfo m_inventoryItems;
+    MappingInfo m_serviceBookings;
+    MappingInfo m_jobCards;
+    MappingInfo m_invoices;
+    MappingInfo m_serviceManagementObservers;
+    MappingInfo m_paymentManagementObservers;
+    MappingInfo m_inventoryManagementObservers;
+    util::Map<std::string, TrackedRecord<User>> m_userCache;
+    util::Map<std::string, TrackedRecord<Notification>> m_notificationCache;
+    util::Map<std::string, TrackedRecord<Service>> m_serviceCache;
+    util::Map<std::string, TrackedRecord<ComboPackage>> m_comboPackageCache;
+    util::Map<std::string, TrackedRecord<InventoryItem>> m_inventoryItemCache;
+    util::Map<std::string, TrackedRecord<ServiceBooking>> m_serviceBookingCache;
+    util::Map<std::string, TrackedRecord<JobCard>> m_jobCardCache;
+    util::Map<std::string, TrackedRecord<Invoice>> m_invoiceCache;
+public:
+    static DataStore& getInstance();
+    bool initialize();
+    void shutdown();
+    util::Map<std::string, TrackedRecord<User>>& getUsers();
+    util::Map<std::string, TrackedRecord<Notification>>& getNotifications();
+    util::Map<std::string, TrackedRecord<Service>>& getServices();
+    util::Map<std::string, TrackedRecord<ComboPackage>>& getComboPackages();
+    util::Map<std::string, TrackedRecord<InventoryItem>>& getInventoryItems();
+    util::Map<std::string, TrackedRecord<ServiceBooking>>& getServiceBookings();
+    util::Map<std::string, TrackedRecord<JobCard>>& getJobCards();
+    util::Map<std::string, TrackedRecord<Invoice>>& getInvoices();
+    util::Map<std::string, User*> getServiceManagementObservers();
+    util::Map<std::string, User*> getPaymentManagementObservers();
+    util::Map<std::string, User*> getInventoryManagementObservers();
+    void saveUsers();
+    void saveNotifications();
+    void saveServices();
+    void saveComboPackages();
+    void saveInventoryItems();
+    void saveServiceBookings();
+    void saveJobCards();
+    void saveInvoices();
+    void saveServiceManagementObservers(util::Map<std::string, User*>& observers);
+    void savePaymentManagementObservers(util::Map<std::string, User*>& observers);
+    void saveInventoryManagementObservers(util::Map<std::string, User*>& observers);
+    bool lockDataStore();
+    bool unlockDataStore();
+private:
+    template<typename TObject, typename TSerialized>
+    util::Map<std::string, TrackedRecord<TObject>> loadRecords(MappingInfo& mapping);
+    template<typename TObject, typename TSerialized>
+    void saveRecords(MappingInfo& mapping, util::Map<std::string, TrackedRecord<TObject>>& records);
+    template<typename TObject> void clearCache(util::Map<std::string, TrackedRecord<TObject>>&cache);
+    template<typename TObject> void refreshCache(util::Map<std::string, TrackedRecord<TObject>>&cache, util::Map<std::string, TrackedRecord<TObject>>&refreshedCache);
+    util::Map<std::string, User*> getObservers(MappingInfo& mapping);
+    void saveObservers(MappingInfo& mapping, util::Map<std::string, User*>& observers);
+};
+
+/*
+Function: loadRecords
+Description: Loads all serialized records from the specified
+             shared-memory mapping, deserializes them into
+             application objects, and returns them as a map
+             of tracked records. Each loaded record is marked
+             as CLEAN and assigned its corresponding slot index
+             within the mapping so that future modifications
+             can be written back efficiently.
+Parameter:
+    - mapping: Reference to the mapping containing the
+               serialized records.
+Return type:
+    util::Map<std::string, TrackedRecord<TObject>>
+             A map containing all loaded records keyed by
+             their unique identifier.
+*/
+template<typename TObject, typename TSerialized>
+util::Map<std::string, TrackedRecord<TObject>> DataStore::loadRecords(MappingInfo& mapping)
+{
+    util::Map<std::string, TrackedRecord<TObject>> records;
+    SharedMemory::ensureLatestMapping(mapping);
+    size_t recordCount = SharedMemory::getRecordCount(mapping);
+    for (size_t index = 0; index < recordCount; ++index)
+    {
+        TSerialized* serialized = static_cast<TSerialized*>(SharedMemory::getRecordAddress(mapping,index));
+        TObject* object = TObject::deserialize(*serialized);
+        TrackedRecord<TObject> trackedRecord;
+        trackedRecord.data = object;
+        trackedRecord.state = RecordState::CLEAN;
+        trackedRecord.slotIndex = index;
+        records.insert(object->getId(), trackedRecord);
+    }
+    return records;
+}
+
+/*
+Function: saveRecords
+Description: Persists all modified and newly added records
+             contained in the provided map to the specified
+             shared-memory mapping. Modified records overwrite
+             their existing slots, while new records are
+             appended to the end of the mapping. Records marked
+             as CLEAN are ignored.
+Parameter:
+    - mapping: Reference to the mapping where records are
+               stored.
+    - records: Map containing the records to be persisted.
+Return type: void
+*/
+template<typename TObject, typename TSerialized> void DataStore::saveRecords(MappingInfo& mapping, util::Map<std::string, TrackedRecord<TObject>>& records)
+{
+    SharedMemory::ensureLatestMapping(mapping);
+    for (int index = 0; index < records.getSize(); ++index)
+    {
+        TrackedRecord<TObject>& record = records.getValueAt(index);
+        if (record.state == RecordState::CLEAN)
+        {
+            continue;
+        }
+        TSerialized serialized = record.data->serialize();
+        if (record.state == RecordState::MODIFIED)
+        {
+            TSerialized* destination = static_cast<TSerialized*>(SharedMemory::getRecordAddress(mapping, record.slotIndex));
+            if (destination)
+            {
+                *destination = serialized;
+            }
+        }
+        else if (record.state == RecordState::NEW_RECORD)
+        {
+            if (!SharedMemory::ensureCapacityForInsert(mapping))
+            {
+                continue;
+            }
+            size_t recordCount = SharedMemory::getRecordCount(mapping);
+            TSerialized* destination = static_cast<TSerialized*>(SharedMemory::getRecordAddress(mapping,recordCount));
+            *destination = serialized;
+            SharedMemory::setRecordCount(mapping, recordCount + 1);
+            record.slotIndex = recordCount;
+        }
+        record.state = RecordState::CLEAN;
+    }
+}
+
+/*
+Function: clearCache
+Description: Releases all objects owned by the cache and
+             clears the cache contents.
+Parameters:
+    - cache: Cache to be cleared.
+Returns:
+    - None
+*/
+template<typename TObject>
+void DataStore::clearCache(util::Map<std::string, TrackedRecord<TObject>>&cache)
+{
+    for (int index = 0; index < cache.getSize(); ++index)
+    {
+        delete cache.getValueAt(index).data;
+        cache.getValueAt(index).data = nullptr;
+    }
+    cache.clear();
+}
+
+/*
+Function: refreshCache
+Description: Refreshes the cache while preserving object addresses
+             for records that already exist. Existing objects are
+             updated in-place so that pointers held elsewhere remain
+             valid after the refresh.
+Parameters:
+    - cache: Existing cache to refresh.
+    - refreshedCache: Newly loaded cache contents.
+Returns:
+    - None
+*/
+template<typename TObject>
+void DataStore::refreshCache(util::Map<std::string, TrackedRecord<TObject>>& cache, util::Map<std::string, TrackedRecord<TObject>>& refreshedCache)
+{
+    util::Map<std::string, TrackedRecord<TObject>> oldCache = cache;
+    cache.clear();
+    for (int index = 0; index < refreshedCache.getSize(); ++index)
+    {
+        const std::string& id = refreshedCache.getKeyAt(index);
+        TrackedRecord<TObject>& refreshedRecord = refreshedCache.getValueAt(index);
+        int oldIndex = oldCache.find(id);
+        if (oldIndex != -1)
+        {
+            TrackedRecord<TObject>& oldRecord = oldCache.getValueAt(oldIndex);
+            *oldRecord.data = *refreshedRecord.data;
+            oldRecord.slotIndex = refreshedRecord.slotIndex;
+            oldRecord.state = refreshedRecord.state;
+            delete refreshedRecord.data;
+            refreshedRecord.data = oldRecord.data;
+        }
+        cache.insert(id, refreshedRecord);
+    }
+    for (int index = 0; index < oldCache.getSize(); ++index)
+    {
+        const std::string& id = oldCache.getKeyAt(index);
+        const TrackedRecord<TObject>& localTrackedRecord = oldCache.getValueAt(index);
+        if (cache.find(id) == -1)
+        {
+            if (localTrackedRecord.state == RecordState::NEW_RECORD)
+            {
+                cache.insert(id, localTrackedRecord);
+            }
+            else
+            {
+                delete localTrackedRecord.data;
+            }
+        }
+    }
+}

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

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

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/datastores/sharedmemory/FileHeader.h

@@ -0,0 +1,17 @@
+/*
+File: FileHeader.h
+Description: Defines the FileHeader structure used to store
+             metadata for binary record files, including
+             record count and capacity.
+Author: Trenser
+Created: 10-June-2026
+*/
+
+#pragma once
+#include <cstddef>
+
+struct FileHeader
+{
+    size_t recordCount;
+    size_t capacity;
+};

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/datastores/sharedmemory/MappingInfo.h

@@ -0,0 +1,29 @@
+/*
+File: MappingInfo.h
+Description: Defines the MappingInfo structure used for
+             managing Windows file mapping operations.
+             Stores handles, mapped view pointer,
+             file metadata, and capacity information.
+Author: Trenser
+Created: 10-June-2026
+*/
+
+#pragma once
+#include <windows.h>
+#include <string>
+
+struct MappingInfo
+{
+    HANDLE fileHandle;
+    HANDLE mappingHandle;
+    void* mappedView;
+    std::string fileName;
+    size_t recordSize;
+    size_t mappedCapacity;
+    MappingInfo()
+        : fileHandle(NULL),
+        mappingHandle(NULL),
+        mappedView(nullptr),
+        recordSize(0),
+        mappedCapacity(0) {}
+};

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/datastores/sharedmemory/RecordState.h

@@ -0,0 +1,17 @@
+/*
+File: RecordState.h
+Description: Defines the RecordState enumeration used to
+             represent the state of a record in storage.
+             States include CLEAN, NEW_RECORD, and MODIFIED.
+Author: Trenser
+Created: 10-June-2026
+*/
+
+#pragma once
+
+enum class RecordState : int
+{
+    CLEAN,
+    NEW_RECORD,
+    MODIFIED
+};

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/datastores/sharedmemory/SerializedRecords.h

@@ -0,0 +1,109 @@
+/*
+File: SerializedRecords.h
+Description: Defines serialized structures for persistent storage
+             and retrieval of system entities including User,
+             Notification, Service, ComboPackage, InventoryItem,
+             ServiceBooking, JobCard, Invoice, and Observer.
+             These structures use fixed-size character arrays
+             and primitive types for binary serialization.
+Author: Trenser
+Created: 10-June-2026
+*/
+
+#pragma once
+#include "Utility.h"
+#include "Enums.h"
+#include "Timestamp.h"
+
+struct SerializedUser
+{
+    char id[64];
+    char username[64];
+    char password[64];
+    char name[128];
+    char phone[32];
+    char email[128];
+    util::UserType userType;
+    util::State status;
+};
+
+struct SerializedNotification
+{
+    char id[64];
+    char recipientUserId[64];
+    char title[128];
+    char message[1024];
+    util::Timestamp createdAt;
+    util::State state;
+};
+
+struct SerializedService
+{
+    char id[64];
+    char name[128];
+    char inventoryItemIDs[1024];
+    double laborCost;
+    util::State status;
+};
+
+struct SerializedComboPackage
+{
+    char id[64];
+    char packageName[128];
+    double discountPercentage;
+    char serviceIDs[1024];
+    util::State status;
+};
+
+struct SerializedInventoryItem
+{
+    char id[64];
+    char partName[128];
+    int quantity;
+    double price;
+    util::State status;
+};
+
+struct SerializedServiceBooking
+{
+    char id[64];
+    util::ServiceJobStatus status;
+    char serviceIDs[1024];
+    char customerId[64];
+    char vehicleNumber[64];
+    char vehicleBrand[64];
+    char vehicleModel[64];
+    char assignedTechnicianId[64];
+    double discountPercentage;
+};
+
+struct SerializedJobCard
+{
+    char id[64];
+    char bookingId[64];
+    char serviceId[64];
+    char technicianId[64];
+    util::Timestamp assignedDate;
+    util::ServiceJobStatus status;
+    util::Timestamp completionDate;
+};
+
+struct SerializedInvoice
+{
+    char id[64];
+    char bookingId[64];
+    util::Timestamp invoiceDate;
+    char partIDs[1024];
+    double laborCost;
+    double partsCost;
+    double discountPercentage;
+    double totalAmount;
+    util::Timestamp paymentDate;
+    util::PaymentMode paymentMethod;
+    util::PaymentStatus status;
+};
+
+struct SerializedObserver
+{
+    char id[64];
+};

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

@@ -0,0 +1,386 @@
+/*
+File: SharedMemory.cpp
+Description: Implements shared memory utilities for managing
+             Windows file mapping operations. Provides functions
+             to create, open, resize, and close mappings, as well
+             as access headers, records, and ensure synchronization
+             across processes.
+Author: Trenser
+Created: 11-June-2026
+*/
+
+#include "SharedMemory.h"
+#include "Windows.h"
+#include "Config.h"
+
+/*
+Function: invalidateMapping
+Description: Releases all mapping resources and resets the mapping to an invalid state.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+Returns:
+    - None
+*/
+static void invalidateMapping(MappingInfo& mapping)
+{
+    if (mapping.mappedView != nullptr)
+    {
+        UnmapViewOfFile(mapping.mappedView);
+        mapping.mappedView = nullptr;
+    }
+    if (mapping.mappingHandle != NULL)
+    {
+        CloseHandle(mapping.mappingHandle);
+        mapping.mappingHandle = NULL;
+    }
+    if (mapping.fileHandle != INVALID_HANDLE_VALUE)
+    {
+        CloseHandle(mapping.fileHandle);
+        mapping.fileHandle = INVALID_HANDLE_VALUE;
+    }
+    mapping.mappedCapacity = 0;
+}
+
+/*
+Function: createOrOpenMapping
+Description: Creates or opens a file mapping and maps it into the process address space.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+Returns:
+    - bool: True if the mapping was successfully created/opened, otherwise false
+*/
+bool SharedMemory::createOrOpenMapping(MappingInfo& mapping)
+{
+    if (mapping.recordSize == 0)
+    {
+        return false;
+    }
+    mapping.fileHandle =
+        CreateFileA(
+            mapping.fileName.c_str(),
+            GENERIC_READ | GENERIC_WRITE,
+            FILE_SHARE_READ | FILE_SHARE_WRITE,
+            NULL,
+            OPEN_ALWAYS,
+            FILE_ATTRIBUTE_NORMAL,
+            NULL);
+    if (mapping.fileHandle == INVALID_HANDLE_VALUE)
+    {
+        return false;
+    }
+    LARGE_INTEGER fileSize;
+    if (!GetFileSizeEx(mapping.fileHandle, &fileSize))
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    bool isNewFile = (fileSize.QuadPart == 0);
+    const size_t initialCapacity = config::file::INITIAL_CAPACITY;
+    if (isNewFile)
+    {
+        LARGE_INTEGER newSize;
+        newSize.QuadPart = sizeof(FileHeader) + initialCapacity * mapping.recordSize;
+        if (!SetFilePointerEx(mapping.fileHandle, newSize, NULL, FILE_BEGIN))
+        {
+            invalidateMapping(mapping);
+            return false;
+        }
+        if (!SetEndOfFile(mapping.fileHandle))
+        {
+            invalidateMapping(mapping);
+            return false;
+        }
+    }
+    mapping.mappingHandle =
+        CreateFileMappingA(
+            mapping.fileHandle,
+            NULL,
+            PAGE_READWRITE,
+            0,
+            0,
+            NULL);
+    if (mapping.mappingHandle == NULL)
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    mapping.mappedView =
+        MapViewOfFile(
+            mapping.mappingHandle,
+            FILE_MAP_ALL_ACCESS,
+            0,
+            0,
+            0);
+    if (mapping.mappedView == nullptr)
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    FileHeader* header = getHeader(mapping);
+    if (header == nullptr)
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    if (isNewFile)
+    {
+        header->recordCount = 0;
+        header->capacity = initialCapacity;
+    }
+    mapping.mappedCapacity = header->capacity;
+    return true;
+}
+
+/*
+Function: closeMapping
+Description: Unmaps and closes all resources associated with a file mapping.
+Parameters:
+    - mapping: MappingInfo&, mapping to close
+Returns:
+    - None
+*/
+void SharedMemory::closeMapping(MappingInfo& mapping)
+{
+    invalidateMapping(mapping);
+}
+
+/*
+Function: getHeader
+Description: Returns the file header stored at the beginning of the mapped memory region.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+Returns:
+    - FileHeader*: Pointer to the file header, or nullptr if the mapping is not valid
+*/
+FileHeader* SharedMemory::getHeader(MappingInfo& mapping)
+{
+    if (mapping.mappedView == nullptr)
+    {
+        return nullptr;
+    }
+    return reinterpret_cast<FileHeader*>(mapping.mappedView);
+}
+
+/*
+Function: getRecordAddress
+Description: Returns the address of a record at the specified index within the mapped memory region.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+    - index: size_t, record index
+Returns:
+    - void*: Pointer to the record, or nullptr if the mapping is not valid
+*/
+void* SharedMemory::getRecordAddress(MappingInfo& mapping, size_t index)
+{
+    if (mapping.mappedView == nullptr)
+    {
+        return nullptr;
+    }
+    return reinterpret_cast<char*>(mapping.mappedView) + sizeof(FileHeader) + index * mapping.recordSize;
+}
+
+/*
+Function: getRecordCount
+Description: Returns the number of records currently stored in the mapping.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+Returns:
+    - size_t: Number of records in the mapping
+*/
+size_t SharedMemory::getRecordCount(MappingInfo& mapping)
+{
+    FileHeader* header = getHeader(mapping);
+    if (header == nullptr)
+    {
+        return 0;
+    }
+    return header->recordCount;
+}
+
+/*
+Function: setRecordCount
+Description: Updates the number of records stored in the mapping.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+    - count: size_t, new record count
+Returns:
+    - None
+*/
+void SharedMemory::setRecordCount(MappingInfo& mapping, size_t count)
+{
+    FileHeader* header = getHeader(mapping);
+    if (header == nullptr)
+    {
+        return;
+    }
+    header->recordCount = count;
+}
+
+/*
+Function: getCapacity
+Description: Returns the current capacity of the mapping.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+Returns:
+    - size_t: Maximum number of records that can be stored in the mapping
+*/
+size_t SharedMemory::getCapacity(MappingInfo& mapping)
+{
+    FileHeader* header = getHeader(mapping);
+    if (header == nullptr)
+    {
+        return 0;
+    }
+    return header->capacity;
+}
+
+/*
+Function: resizeMapping
+Description: Resizes the file mapping to the specified capacity.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+    - newCapacity: size_t, new mapping capacity
+Returns:
+    - bool: True if the resize succeeded, otherwise false
+*/
+bool SharedMemory::resizeMapping(MappingInfo& mapping, size_t newCapacity)
+{
+    FileHeader* header = getHeader(mapping);
+    if (header == nullptr)
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    header->capacity = newCapacity;
+    if (!FlushViewOfFile(mapping.mappedView, sizeof(FileHeader)))
+    {
+        return false;
+    }
+    if (!UnmapViewOfFile(mapping.mappedView))
+    {
+        return false;
+    }
+    mapping.mappedView = nullptr;
+    CloseHandle(mapping.mappingHandle);
+    mapping.mappingHandle = NULL;
+    LARGE_INTEGER newSize;
+    newSize.QuadPart = sizeof(FileHeader) + newCapacity * mapping.recordSize;
+    if (!SetFilePointerEx(mapping.fileHandle, newSize, NULL, FILE_BEGIN))
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    if (!SetEndOfFile(mapping.fileHandle))
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    mapping.mappingHandle =
+        CreateFileMappingA(
+            mapping.fileHandle,
+            NULL,
+            PAGE_READWRITE,
+            0,
+            0,
+            NULL);
+    if (mapping.mappingHandle == NULL)
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    mapping.mappedView =
+        MapViewOfFile(
+            mapping.mappingHandle,
+            FILE_MAP_ALL_ACCESS,
+            0,
+            0,
+            0);
+    if (mapping.mappedView == nullptr)
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    mapping.mappedCapacity = newCapacity;
+    return true;
+}
+
+/*
+Function: ensureCapacityForInsert
+Description: Ensures that the mapping has space for at least one additional record, growing it if necessary.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+Returns:
+    - bool: True if capacity is available, otherwise false
+*/
+bool SharedMemory::ensureCapacityForInsert(MappingInfo& mapping)
+{
+    size_t recordCount = getRecordCount(mapping);
+    size_t capacity = getCapacity(mapping);
+    if (recordCount < capacity)
+    {
+        return true;
+    }
+    return resizeMapping(mapping, capacity * config::file::GROWTH_FACTOR);
+}
+
+/*
+Function: ensureLatestMapping
+Description: Remaps the file if another process has resized it.
+Parameters:
+    - mapping: MappingInfo&, mapping information and handles
+Returns:
+    - bool: True if the mapping is valid and up to date, otherwise false
+*/
+bool SharedMemory::ensureLatestMapping(MappingInfo& mapping)
+{
+    FileHeader* header = getHeader(mapping);
+    if (header == nullptr)
+    {
+        return false;
+    }
+    if (header->capacity == mapping.mappedCapacity)
+    {
+        return true;
+    }
+    if (!UnmapViewOfFile(mapping.mappedView))
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    mapping.mappedView = nullptr;
+    CloseHandle(mapping.mappingHandle);
+    mapping.mappingHandle = NULL;
+    mapping.mappingHandle =
+        CreateFileMappingA(
+            mapping.fileHandle,
+            NULL,
+            PAGE_READWRITE,
+            0,
+            0,
+            NULL);
+    if (mapping.mappingHandle == NULL)
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    mapping.mappedView =
+        MapViewOfFile(
+            mapping.mappingHandle,
+            FILE_MAP_ALL_ACCESS,
+            0,
+            0,
+            0);
+    if (mapping.mappedView == nullptr)
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    header = getHeader(mapping);
+    if (header == nullptr)
+    {
+        invalidateMapping(mapping);
+        return false;
+    }
+    mapping.mappedCapacity = header->capacity;
+    return true;
+}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/datastores/sharedmemory/SharedMemory.h

@@ -0,0 +1,29 @@
+/*
+File: SharedMemory.h
+Description: Declares functions for managing Windows file
+             mapping and shared memory operations. Provides
+             utilities for creating, resizing, and closing
+             mappings, as well as accessing headers and
+             record data.
+Author: Trenser
+Created: 10-June-2026
+*/
+
+#pragma once
+#include <cstddef>
+#include "MappingInfo.h"
+#include "FileHeader.h"
+
+namespace SharedMemory
+{
+    bool createOrOpenMapping(MappingInfo& mapping);
+    void closeMapping(MappingInfo& mapping);
+    bool ensureLatestMapping(MappingInfo& mapping);
+    bool resizeMapping(MappingInfo& mapping, size_t newCapacity);
+    FileHeader* getHeader(MappingInfo& mapping);
+    void* getRecordAddress(MappingInfo& mapping, size_t index);
+    size_t getRecordCount(MappingInfo& mapping);
+    void setRecordCount(MappingInfo& mapping, size_t count);
+    size_t getCapacity(MappingInfo& mapping);
+    bool ensureCapacityForInsert(MappingInfo& mapping);
+};

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/datastores/sharedmemory/TrackedRecord.h

@@ -0,0 +1,33 @@
+/*
+File: TrackedRecord.h
+Description: Defines the TrackedRecord template structure used
+             to manage objects with associated record state and
+             slot index. Supports tracking of CLEAN, NEW_RECORD,
+             and MODIFIED states for persistence and synchronization.
+Author: Trenser
+Created: 10-June-2026
+*/
+
+#pragma once
+#include "RecordState.h"
+
+static const size_t INVALID_SLOT = static_cast<size_t>(-1);
+
+template<typename T>
+struct TrackedRecord
+{
+    T* data;
+    RecordState state;
+    size_t slotIndex;
+    TrackedRecord()
+        : data(nullptr),
+        state(RecordState::CLEAN),
+        slotIndex(INVALID_SLOT) {}
+    TrackedRecord(
+        T* object,
+        RecordState recordState,
+        size_t slot)
+        : data(object),
+        state(recordState),
+        slotIndex(slot) {}
+};

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

@@ -9,6 +9,7 @@ Date: 19-May-2026
 
 #include <sstream>
 #include <stdexcept>
+#include "SerializedRecords.h"
 #include "ComboPackage.h"
 #include "Service.h"
 #include "Factory.h"
@@ -28,7 +29,8 @@ 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
@@ -270,72 +272,38 @@ static util::Vector<std::string> getServiceIDsAsVector(const std::string& servic
 
 /*
 Function: serialize
-Description: Serializes the combo package into a CSV-formatted string.
+Description: Serializes the ComboPackage object into a SerializedComboPackage record.
 Parameters:
     - None
 Returns:
-    - std::string: Serialized combo package record
+    - SerializedComboPackage: Serialized representation of the combo package
 */
-std::string ComboPackage::serialize() const
+SerializedComboPackage ComboPackage::serialize() const
 {
-    std::ostringstream serializedComboPackage;
-    serializedComboPackage << m_id << ','
-        << m_packageName << ','
-        << m_discountPercentage << ','
-        << getServiceIDsAsString(m_serviceIDs) << ','
-        << util::getStateString(m_status);
-    return serializedComboPackage.str();
+    SerializedComboPackage serialized = {};
+    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
+    strcpy_s(serialized.packageName, sizeof(serialized.packageName), m_packageName.c_str());
+    strcpy_s(serialized.serviceIDs, sizeof(serialized.serviceIDs), getServiceIDsAsString(m_serviceIDs).c_str());
+    serialized.discountPercentage = m_discountPercentage;
+    serialized.status = m_status;
+    return serialized;
 }
 
 /*
 Function: deserialize
-Description: Deserializes a CSV-formatted string into a ComboPackage object.
+Description: Deserializes a SerializedComboPackage record into a ComboPackage object.
 Parameters:
-    - record: const std::string&, serialized combo package record
+    - serializedComboPackage: const SerializedComboPackage&, serialized combo package record
 Returns:
     - ComboPackage*: Pointer to the deserialized ComboPackage object
-Throws:
-    - std::runtime_error if data is invalid
 */
-ComboPackage* ComboPackage::deserialize(const std::string& record)
+ComboPackage* ComboPackage::deserialize(const SerializedComboPackage& serializedComboPackage)
 {
-    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);
+    util::Vector<std::string> serviceIDs = getServiceIDsAsVector(serializedComboPackage.serviceIDs);
     return Factory::getObject<ComboPackage>(
-        id,
-        packageName,
-        discountPercentage,
+        serializedComboPackage.id,
+        serializedComboPackage.packageName,
+        serializedComboPackage.discountPercentage,
         serviceIDs,
-        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";
-}
+        serializedComboPackage.status);
+}

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

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

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

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

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

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

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

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

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

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

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

@@ -8,6 +8,7 @@ Date: 19-May-2026
 */
 
 #include <sstream>
+#include "SerializedRecords.h"
 #include "Service.h"
 #include "InventoryItem.h"
 #include "StringHelper.h"
@@ -27,7 +28,8 @@ 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
@@ -44,7 +46,7 @@ Service::Service(const std::string& name, const util::Map<std::string, Inventory
     m_name(name),
     m_requiredInventoryItems(requiredInventoryItems),
     m_status(util::State::ACTIVE),
-    m_laborCost(laborCost) 
+    m_laborCost(laborCost)
 {
     int numberOfInventoryItems = m_requiredInventoryItems.getSize();
     auto inventoryItemPointers = m_requiredInventoryItems.getValues();
@@ -266,72 +268,38 @@ static util::Vector<std::string> getInventoryItemIDsAsVector(const std::string&
 
 /*
 Function: serialize
-Description: Serializes the service into a CSV-formatted string.
+Description: Serializes the Service object into a SerializedService record.
 Parameters:
     - None
 Returns:
-    - std::string: Serialized service record
+    - SerializedService: Serialized representation of the service
 */
-std::string Service::serialize() const
+SerializedService Service::serialize() const
 {
-    std::ostringstream serializedService;
-    serializedService << m_id << ','
-        << m_name << ','
-        << getInventoryItemIDsAsString(m_requiredInventoryItemIDs) << ','
-        << m_laborCost << ','
-        << util::getStateString(m_status);
-    return serializedService.str();
+    SerializedService serialized = {};
+    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
+    strcpy_s(serialized.name, sizeof(serialized.name), m_name.c_str());
+    strcpy_s(serialized.inventoryItemIDs, sizeof(serialized.inventoryItemIDs), getInventoryItemIDsAsString(m_requiredInventoryItemIDs).c_str());
+    serialized.laborCost = m_laborCost;
+    serialized.status = m_status;
+    return serialized;
 }
 
 /*
 Function: deserialize
-Description: Deserializes a CSV-formatted string into a Service object.
+Description: Deserializes a SerializedService record into a Service object.
 Parameters:
-    - record: const std::string&, serialized service record
+    - serializedService: const SerializedService&, serialized service record
 Returns:
     - Service*: Pointer to the deserialized Service object
-Throws:
-    - std::runtime_error if labor cost parsing fails
 */
-Service* Service::deserialize(const std::string& record)
+Service* Service::deserialize(const SerializedService& serializedService)
 {
-    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);
+    util::Vector<std::string> inventoryItemIDs = getInventoryItemIDsAsVector(serializedService.inventoryItemIDs);
     return Factory::getObject<Service>(
-        id,
-        name,
+        serializedService.id,
+        serializedService.name,
         inventoryItemIDs,
-        laborCost,
-        status
-    );
-}
-
-/*
-Function: getHeaders
-Description: Retrieves the CSV headers for service serialization.
-Parameters:
-    - None
-Returns:
-    - std::string: Header string ("ID,Name,InventoryIDs,LaborCost,Status")
-*/
-std::string Service::getHeaders()
-{
-    return "ID,Name,InventoryIDs,LaborCost,Status";
+        serializedService.laborCost,
+        serializedService.status);
 }

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

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

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

@@ -6,8 +6,10 @@ 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"
@@ -28,7 +30,8 @@ ServiceBooking::ServiceBooking()
     m_customer(nullptr),
     m_assignedTechnician(nullptr),
     m_status(util::ServiceJobStatus::PENDING),
-    m_discountPercentage(0.0) {}
+    m_discountPercentage(0.0) {
+}
 
 /*
 Function: ServiceBooking
@@ -437,84 +440,46 @@ static util::Vector<std::string> getServiceIDsAsVector(const std::string& servic
 
 /*
 Function: serialize
-Description: Serializes the service booking into a CSV-formatted string.
+Description: Serializes the ServiceBooking object into a SerializedServiceBooking record.
 Parameters:
     - None
 Returns:
-    - std::string: Serialized booking record
+    - SerializedServiceBooking: Serialized representation of the service booking
 */
-std::string ServiceBooking::serialize() const
+SerializedServiceBooking ServiceBooking::serialize() const
 {
-    std::ostringstream serializedBooking;
-    serializedBooking << m_id << ','
-        << util::getServiceJobStatusString(m_status) << ','
-        << getServiceIDsAsString(m_serviceIDs) << ','
-        << m_customerId << ','
-        << m_vehicleNumber << ','
-        << m_vehicleBrand << ','
-        << m_vehicleModel << ','
-        << m_assignedTechnicianId << ','
-        << m_discountPercentage << ',';
-    return serializedBooking.str();
+    SerializedServiceBooking serialized = {};
+    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
+    strcpy_s(serialized.serviceIDs, sizeof(serialized.serviceIDs), getServiceIDsAsString(m_serviceIDs).c_str());
+    strcpy_s(serialized.customerId, sizeof(serialized.customerId), m_customerId.c_str());
+    strcpy_s(serialized.vehicleNumber, sizeof(serialized.vehicleNumber), m_vehicleNumber.c_str());
+    strcpy_s(serialized.vehicleBrand, sizeof(serialized.vehicleBrand), m_vehicleBrand.c_str());
+    strcpy_s(serialized.vehicleModel, sizeof(serialized.vehicleModel), m_vehicleModel.c_str());
+    strcpy_s(serialized.assignedTechnicianId, sizeof(serialized.assignedTechnicianId), m_assignedTechnicianId.c_str());
+    serialized.status = m_status;
+    serialized.discountPercentage = m_discountPercentage;
+    return serialized;
 }
 
 /*
 Function: deserialize
-Description: Deserializes a CSV-formatted string into a ServiceBooking object.
+Description: Deserializes a SerializedServiceBooking record into a ServiceBooking object.
 Parameters:
-    - record: const std::string&, serialized booking record
+    - serializedServiceBooking: const SerializedServiceBooking&, serialized service booking record
 Returns:
     - ServiceBooking*: Pointer to the deserialized ServiceBooking object
-Throws:
-    - std::runtime_error if discount percentage parsing fails
 */
-ServiceBooking* ServiceBooking::deserialize(const std::string& record)
+ServiceBooking* ServiceBooking::deserialize(const SerializedServiceBooking& serializedServiceBooking)
 {
-    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);
+    util::Vector<std::string> serviceIDs = getServiceIDsAsVector(serializedServiceBooking.serviceIDs);
     return Factory::getObject<ServiceBooking>(
-        id,
-        status,
+        serializedServiceBooking.id,
+        serializedServiceBooking.status,
         serviceIDs,
-        customerId,
-        vehicleNumber,
-        vehicleBrand,
-        vehicleModel,
-        assignedTechnicianId,
-        discountPercentage
-    );
-}
-
-/*
-Function: getHeaders
-Description: Retrieves the CSV headers for service booking serialization.
-Parameters:
-    - None
-Returns:
-    - std::string: Header string ("ID,Status,ServiceIDs,CustomerID,VehicleNumber,VehicleBrand,VehicleModel,AssignedTechnicianID,DiscountPercentage")
-*/
-std::string ServiceBooking::getHeaders()
-{
-    return "ID,Status,ServiceIDs,CustomerID,VehicleNumber,VehicleBrand,VehicleModel,AssignedTechnicianID,DiscountPercentage";
+        serializedServiceBooking.customerId,
+        serializedServiceBooking.vehicleNumber,
+        serializedServiceBooking.vehicleBrand,
+        serializedServiceBooking.vehicleModel,
+        serializedServiceBooking.assignedTechnicianId,
+        serializedServiceBooking.discountPercentage);
 }

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

@@ -6,6 +6,7 @@ Description: Header file declaring the ServiceBooking class, which represents
 Author: Trenser
 Date:19-May-2026
 */
+
 #pragma once
 #include <string>
 #include "Map.h"
@@ -14,6 +15,7 @@ Date:19-May-2026
 
 class Service;
 class User;
+struct SerializedServiceBooking;
 
 class ServiceBooking
 {
@@ -78,7 +80,6 @@ public:
     void setAssignedTechnicianId(const std::string& assignedTechnicianId);
     void setAssignedTechnician(User* assignedTechnician);
     void setDiscountPercentage(double discountPercentage);
-    std::string serialize() const;
-    static ServiceBooking* deserialize(const std::string&);
-    static std::string getHeaders();
+    SerializedServiceBooking serialize() const;
+    static ServiceBooking* deserialize(const SerializedServiceBooking&);
 };

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

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

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

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

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

@@ -10,6 +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;
 
@@ -24,11 +26,12 @@ Return type: bool - true if login successful, false otherwise
 */
 bool AuthenticationManagementService::login(const std::string& username, const std::string& password)
 {
-	util::Map<std::string, User*> users = m_dataStore.getUsers();
-	int usersMapSize = users.getSize();
-	for (int index = 0; index < usersMapSize; index++)
+	DataStoreLockGuard lock(m_dataStore);
+	auto& trackedUserMap = m_dataStore.getUsers();
+	int trackedUserMapSize = trackedUserMap.getSize();
+	for (int index = 0; index < trackedUserMapSize; index++)
 	{
-		User* user = users.getValueAt(index);
+		User* user = trackedUserMap.getValueAt(index).data;
 		if (username == user->getUserName())
 		{
 			if (password == user->getPassword())
@@ -74,9 +77,18 @@ Return type: void
 */
 void AuthenticationManagementService::changePassword(const std::string& newPassword)
 {
+	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();
 }

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

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

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

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

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

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

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

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

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

@@ -11,7 +11,6 @@ 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"
@@ -21,6 +20,7 @@ Date: 20-May-2026
 #include "Timestamp.h"
 #include "User.h"
 #include "Utility.h"
+#include "DataStoreLockGuard.h"
 
 util::Map<std::string, User*> PaymentManagementService::m_observers{};
 
@@ -34,6 +34,9 @@ Returns:
 */
 void PaymentManagementService::attach(User* user)
 {
+	DataStoreLockGuard lock(m_dataStore);
+	m_observers.clear();
+	m_observers = m_dataStore.getPaymentManagementObservers();
 	if (user)
 	{
 		const std::string& userID = user->getId();
@@ -42,6 +45,7 @@ void PaymentManagementService::attach(User* user)
 			m_observers[userID] = user;
 		}
 	}
+	m_dataStore.savePaymentManagementObservers(m_observers);
 }
 
 /*
@@ -54,6 +58,9 @@ Returns:
 */
 void PaymentManagementService::detach(User* user)
 {
+	DataStoreLockGuard lock(m_dataStore);
+	m_observers.clear();
+	m_observers = m_dataStore.getPaymentManagementObservers();
 	if (user)
 	{
 		const std::string& userID = user->getId();
@@ -62,6 +69,7 @@ void PaymentManagementService::detach(User* user)
 			m_observers.remove(userID);
 		}
 	}
+	m_dataStore.savePaymentManagementObservers(m_observers);
 }
 
 /*
@@ -78,28 +86,28 @@ Throws:
 */
 void PaymentManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
 {
-	if (user)
+	if (!user)
 	{
-		if (m_observers.find(user->getId()) != -1)
-		{
-			Notification* notification =
-				Factory::getObject<Notification>(
-					user->getId(),
-					user,
-					title,
-					message,
-					util::Timestamp()
-				);
-			if (notification)
-			{
-				user->addNotification(notification);
-			}
-			else
-			{
-				throw std::runtime_error("Failed to create notification");
-			}
-		}
+		return;
 	}
+	DataStoreLockGuard lock(m_dataStore);
+	m_observers = m_dataStore.getPaymentManagementObservers();
+	if (m_observers.find(user->getId()) == -1)
+	{
+		return;
+	}
+	Notification* notification = Factory::getObject<Notification>(
+		user->getId(),
+		title,
+		message,
+		util::Timestamp());
+	if (!notification)
+	{
+		throw std::runtime_error("Failed to create notification");
+	}
+	auto& trackedNotificationsMap = m_dataStore.getNotifications();
+	trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
+	m_dataStore.saveNotifications();
 }
 
 /*
@@ -140,123 +148,6 @@ void PaymentManagementService::sendPaymentReminders()
 	}
 }
 
-/*
-Function: getObserverIDs
-Description: Retrieves the IDs of all observers currently attached to the
-             PaymentManagementService.
-Parameters:
-    - None
-Returns:
-    - util::Vector<std::string>: Vector of observer user IDs
-*/
-util::Vector<std::string> PaymentManagementService::getObserverIDs()
-{
-	util::Vector<std::string> observerIDs;
-	int numberOfObservers = m_observers.getSize();
-	for (int index = 0; index < numberOfObservers; index++)
-	{
-		User* observer = m_observers.getValueAt(index);
-		if (observer)
-		{
-			observerIDs.push_back(observer->getId());
-		}
-	}
-	return observerIDs;
-}
-
-/*
-Function: loadInvoices
-Description: Loads invoices from persistent storage into the datastore.
-             Validates associated service bookings and inventory parts before
-             attaching them to each invoice. Throws exceptions if invalid IDs
-             are encountered.
-Parameters:
-    - None
-Returns:
-    - void
-Throws:
-    - std::runtime_error if a booking ID or part ID is invalid
-*/
-void PaymentManagementService::loadInvoices()
-{
-    util::FileManager<Invoice> invoiceFileManager(config::file::INVOICE_FILE);
-    auto& invoices = m_dataStore.getInvoices();
-    auto& serviceBookings = m_dataStore.getServiceBookings();
-    auto& inventoryItems = m_dataStore.getInventoryItems();
-    auto invoicesMap = invoiceFileManager.load();
-    for (int invoiceIndex = 0; invoiceIndex < invoicesMap.getSize(); invoiceIndex++)
-    {
-        Invoice* invoice = invoicesMap.getValueAt(invoiceIndex);
-        int bookingIndex = serviceBookings.find(invoice->getBookingId());
-        if (bookingIndex == -1)
-        {
-            throw std::runtime_error("Invalid Booking ID");
-        }
-        ServiceBooking* booking = serviceBookings.getValueAt(bookingIndex);
-        invoice->setBooking(booking);
-        util::Map<std::string, InventoryItem*> invoiceParts;
-        auto& partIDs = invoice->getPartIDs();
-        for (int partIndex = 0; partIndex < partIDs.getSize(); partIndex++)
-        {
-            const std::string& partID = partIDs[partIndex];
-            int inventoryIndex = inventoryItems.find(partID);
-            if (inventoryIndex == -1)
-            {
-                throw std::runtime_error("Invalid Part ID");
-            }
-            invoiceParts[partID] = inventoryItems.getValueAt(inventoryIndex);
-        }
-        invoice->setParts(invoiceParts);
-        invoices[invoice->getId()] = invoice;
-    }
-}
-
-/*
-Function: saveInvoices
-Description: Saves invoices from the datastore to persistent storage.
-             Uses FileManager to serialize invoices into the configured file.
-Parameters:
-    - None
-Returns:
-    - void
-*/
-void PaymentManagementService::saveInvoices()
-{
-    util::FileManager<Invoice> invoiceFileManager(config::file::INVOICE_FILE);
-    auto& invoices = m_dataStore.getInvoices();
-    invoiceFileManager.save(invoices);
-}
-
-/*
-Function: loadObservers
-Description: Loads observer IDs from persistent storage and attaches corresponding
-             users as observers to the PaymentManagementService.
-Parameters:
-    - None
-Returns:
-    - void
-Throws:
-    - std::runtime_error if an observer ID is invalid (not found in datastore)
-*/
-void PaymentManagementService::loadObservers()
-{
-    util::loadObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this, m_dataStore);
-}
-
-/*
-Function: saveObservers
-Description: Saves the current observer IDs of the PaymentManagementService
-             to persistent storage for future retrieval.
-Parameters:
-    - None
-Returns:
-    - void
-*/
-void PaymentManagementService::saveObservers()
-{
-    util::saveObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this);
-}
-
 /*
 Function: createInventoryItemsMap (static helper)
 Description: Builds a map of inventory items required for a given service and adds them to the booking’s inventory map.
@@ -368,12 +259,12 @@ void PaymentManagementService::completePayment(const std::string& invoiceID, uti
 	if (invoiceIndex != -1)
 	{
 		Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
-		if (invoice && invoice->getStatus() != util::PaymentStatus::COMPLETED)
+		if (invoice && invoice->getStatus() != util::PaymentStatus::PAID)
 		{
 			User* currentUser = invoice->getBooking()->getCustomer();
 			invoice->setPaymentMethod(paymentMode);
 			invoice->setPaymentDate(util::Timestamp());
-			invoice->setStatus(util::PaymentStatus::COMPLETED);
+			invoice->setStatus(util::PaymentStatus::PAID);
 			std::string title, message;
 			title = "Payment successful";
 			message = "Payment successful for Invoice ID " + invoiceID;
@@ -384,4 +275,48 @@ void PaymentManagementService::completePayment(const std::string& invoiceID, uti
 	{
 		throw std::runtime_error("Payment failed: invalid invoice ID.");
 	}
+}
+
+/*
+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*>& PaymentManagementService::getAllInvoices()
+{
+	return m_dataStore.getInvoices();
+}
+
+/*
+Function: confirmPayment
+Description: Confirms payment for a specific invoice. Updates payment date and status,
+			 then sends a notification to the customer.
+Parameters:
+	- invoiceID: std::string, ID of the invoice to confirm
+Returns:
+	- void
+Throws:
+	- std::runtime_error if the invoice ID is invalid
+*/
+void PaymentManagementService::confirmPayment(const std::string& invoiceID)
+{
+	auto& currentInvoices = m_dataStore.getInvoices();
+	int invoiceIndex = currentInvoices.find(invoiceID);
+	if (invoiceIndex == -1)
+	{
+		throw std::runtime_error("Payment confirmation failed: invalid invoice ID.");
+	}
+	Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
+	if (!invoice || invoice->getStatus() != util::PaymentStatus::PAID)
+	{
+		throw std::runtime_error("Payment confirmation failed: invoice is not awaiting confirmation.");
+	}
+	User* currentUser = invoice->getBooking()->getCustomer();
+	invoice->setStatus(util::PaymentStatus::COMPLETED);
+	std::string title = "Payment Confirmed";
+	std::string message = "Payment Confirmed for Invoice ID " + invoiceID;
+	sendNotification(currentUser, title, message);
 }

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

@@ -22,18 +22,15 @@ class PaymentManagementService : public NotificationManagementService
 private:
     DataStore& m_dataStore;
     static util::Map<std::string, User*> m_observers;
-    util::Vector<std::string> getObserverIDs() override;
 public:
     PaymentManagementService() : m_dataStore(DataStore::getInstance()) {}
     void generateInvoice(ServiceBooking* booking);
     util::Map<std::string, Invoice*> getInvoices(const std::string& customerID);
     void completePayment(const std::string& invoiceID, util::PaymentMode paymentMode);
+    util::Map<std::string, Invoice*>& getAllInvoices();
+    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,7 +23,6 @@ class ServiceManagementService : public NotificationManagementService
 private:
     DataStore& m_dataStore;
     static util::Map<std::string, User*> m_observers;
-    util::Vector<std::string> getObserverIDs() override;
 public:
     ServiceManagementService() : m_dataStore(DataStore::getInstance()) {}
     util::Map<std::string, Service*> getServices();
@@ -37,7 +36,7 @@ public:
     void createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost);
     void removeService(const std::string& serviceID);
     util::Map<std::string, JobCard*> getJobCards(const std::string& technicianID);
-    void completeJob(const std::string& jobID);
+    void updateJobStatus(const std::string& jobID);
     void cancelCustomerServiceBookings(const std::string& customerID);
     void cancelTechnicianJobs(const std::string& technicianID);
     void createComboPackage(const std::string& packageName, const util::Vector<std::string>& serviceIDs, double discountPercentage);
@@ -45,14 +44,4 @@ public:
     void sendNotification(User* user, const std::string& title, const std::string& message) override;
     void attach(User* user) override;
     void detach(User* user) override;
-    void loadServices();
-    void saveServices();
-    void loadComboPackages();
-    void saveComboPackages();
-    void loadServiceBookings();
-    void saveServiceBookings();
-    void loadJobCards();
-    void saveJobCards();
-    void loadObservers();
-    void saveObservers();
 };

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

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

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

@@ -6,6 +6,7 @@ Description: Header file declaring the UserManagementService class, which manage
 Author: Trenser
 Date:19-May-2026
 */
+
 #pragma once
 #include <string>
 #include "Map.h"
@@ -30,6 +31,4 @@ public:
     util::Vector<Notification*> getUserNotifications(const std::string& userID);
     void deleteNotification(const std::string& notificationID, const std::string& userID);
     void ensureAdminExists();
-    void loadUsers();
-    void saveUsers();
 };

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

@@ -28,16 +28,19 @@ namespace config
 
 	namespace file
 	{
-		constexpr const char* INVENTORYITEM_FILE = "files/InventoryItem.csv";
-		constexpr const char* USER_FILE = "files/User.csv";
-		constexpr const char* NOTIFICATION_FILE = "files/Notification.csv";
-		constexpr const char* SERVICE_FILE = "files/Service.csv";
-		constexpr const char* COMBOPACKAGE_FILE = "files/ComboPackage.csv";
-		constexpr const char* SERVICEBOOKING_FILE = "files/ServiceBooking.csv";
-		constexpr const char* JOBCARD_FILE = "files/JobCard.csv";
-		constexpr const char* INVOICE_FILE = "files/Invoice.csv";
-		constexpr const char* SERVICEMANAGEMENTOBSERVERS = "files/ServiceManagementObservers.csv";
-		constexpr const char* PAYMENTMANAGEMENTOBSERVERS = "files/PaymentManagementObservers.csv";
-		constexpr const char* INVENTORYMANAGEMENTOBSERVERS = "files/InventoryManagementObservers.csv";
+		const size_t INITIAL_CAPACITY = 100;
+		const size_t GROWTH_FACTOR = 2;
+		constexpr const char* DIRECTORY = "files/";
+		constexpr const char* INVENTORYITEM_FILE = "files/InventoryItem.dat";
+		constexpr const char* USER_FILE = "files/User.dat";
+		constexpr const char* NOTIFICATION_FILE = "files/Notification.dat";
+		constexpr const char* SERVICE_FILE = "files/Service.dat";
+		constexpr const char* COMBOPACKAGE_FILE = "files/ComboPackage.dat";
+		constexpr const char* SERVICEBOOKING_FILE = "files/ServiceBooking.dat";
+		constexpr const char* JOBCARD_FILE = "files/JobCard.dat";
+		constexpr const char* INVOICE_FILE = "files/Invoice.dat";
+		constexpr const char* SERVICEMANAGEMENTOBSERVERS = "files/ServiceManagementObservers.dat";
+		constexpr const char* PAYMENTMANAGEMENTOBSERVERS = "files/PaymentManagementObservers.dat";
+		constexpr const char* INVENTORYMANAGEMENTOBSERVERS = "files/InventoryManagementObservers.dat";
 	}
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/Enums.h

@@ -12,35 +12,37 @@ Date: 19-May-2026
 
 namespace util
 {
-	enum class UserType
+	enum class UserType : int
 	{
 		ADMIN,
 		TECHNICIAN,
 		CUSTOMER
 	};
 
-	enum class PaymentMode
+	enum class PaymentMode : int
 	{
 		ONLINE,
 		OFFLINE,
         NOTSET
 	};
 
-	enum class PaymentStatus
+	enum class PaymentStatus : int
 	{
 		PENDING,
-		COMPLETED
+		COMPLETED,
+        PAID
 	};
 
-	enum class ServiceJobStatus
+	enum class ServiceJobStatus : int
 	{
         PENDING,
 		STARTED,
 		COMPLETED,
+        IN_PROGRESS,
         CANCELLED
 	};
 
-    enum class State
+    enum class State : int
     {
         ACTIVE,
         INACTIVE
@@ -160,6 +162,8 @@ namespace util
             return "PENDING";
         case PaymentStatus::COMPLETED:
             return "COMPLETED";
+        case PaymentStatus::PAID:
+            return "PAID";
         }
         throw std::invalid_argument("Invalid PaymentStatus");
     }
@@ -209,6 +213,8 @@ namespace util
             return "COMPLETED";
         case ServiceJobStatus::CANCELLED:
             return "CANCELLED";
+        case ServiceJobStatus::IN_PROGRESS:
+            return "IN_PROGRESS";
         }
         throw std::invalid_argument("Invalid ServiceJobStatus");
     }
@@ -241,6 +247,10 @@ namespace util
         {
             return ServiceJobStatus::CANCELLED;
         }
+        if (value == "IN_PROGRESS")
+        {
+            return ServiceJobStatus::IN_PROGRESS;
+        }
         throw std::invalid_argument("Invalid ServiceJobStatus string");
     }
 

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

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

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

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

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

@@ -10,6 +10,7 @@
 #include <limits>
 #include <string>
 #include <stdexcept>
+#include <conio.h>
 
 namespace util
 {
@@ -27,7 +28,7 @@ namespace util
         if (!(std::cin >> value))
         {
             std::cin.clear();
-            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+            std::cin.ignore((std::numeric_limits<std::streamsize>::max)(), '\n');
             throw std::runtime_error("Invalid console input");
         }
     }
@@ -54,6 +55,48 @@ namespace util
         value = cleanedValue;
     }
 
+    /*
+     * Function: readPassword
+     * Description: Reads a password from console without echoing characters;
+     *              displays '*' for each character typed, handles backspace,
+     *              and cleans commas from the result.
+     * Parameters:
+     *     value - reference to a string where the password will be stored
+     * Returns:
+     *     void - no return value
+     */
+    inline void readPassword(std::string& value)
+    {
+        value.clear();
+        char currentCharacter;
+        while ((currentCharacter = _getch()) != '\r')
+        {
+            if (currentCharacter == '\b')
+            {
+                if (!value.empty())
+                {
+                    value.pop_back();
+                    std::cout << "\b \b";
+                }
+            }
+            else
+            {
+                value += currentCharacter;
+                std::cout << '*';
+            }
+        }
+        std::cout << std::endl;
+        std::string cleanedValue;
+        for (int iterator = 0; iterator < value.length(); iterator++)
+        {
+            if (value[iterator] != ',')
+            {
+                cleanedValue += value[iterator];
+            }
+        }
+        value = cleanedValue;
+    }
+
     /*
      * Function: pressEnter
      * Description: Pauses execution until the user presses Enter.

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

@@ -54,49 +54,79 @@ 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));
-        }
-    }
+    template<typename TObject>
+    Map<std::string, TObject*> getObjects(const Map<std::string, TrackedRecord<TObject>>& trackedRecords);
 
-    /*
-    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)
+    template<typename TObject>
+    Map<std::string, const TObject*> getConstObjects(const Map<std::string, TrackedRecord<TObject>>& trackedRecords);
+
+    template<typename TObject>
+    TrackedRecord<TObject> createNewRecord(TObject* object);
+}
+
+/*
+Function: getObjects
+Description: Extracts the object pointers from a tracked-record
+             collection and returns them as a map keyed by the
+             same identifiers.
+Parameters:
+    - trackedRecords: Collection of tracked records.
+Returns:
+    - Map<std::string, TObject*>: Collection of object pointers.
+*/
+template<typename TObject>
+util::Map<std::string, TObject*> util::getObjects(const util::Map<std::string, TrackedRecord<TObject>>& trackedRecords)
+{
+    util::Map<std::string, TObject*> objects;
+    for (int index = 0; index < trackedRecords.getSize(); ++index)
     {
-        auto observerIDs = service->getObserverIDs();
-        util::saveRecords(filePath, observerIDs);
+        const std::string& key = trackedRecords.getKeyAt(index);
+        TObject* object = trackedRecords.getValueAt(index).data;
+        objects.insert(key, object);
     }
+    return objects;
+}
+
+/*
+Function: getConstObjects
+Description: Extracts the object pointers from a tracked-record
+             collection and returns them as a read-only map
+             keyed by the same identifiers.
+Parameters:
+    - trackedRecords: Collection of tracked records.
+Returns:
+    - Map<std::string, const TObject*>:
+      Collection of read-only object pointers.
+*/
+template<typename TObject>
+util::Map<std::string, const TObject*> util::getConstObjects(
+    const util::Map<std::string, TrackedRecord<TObject>>& trackedRecords)
+{
+    util::Map<std::string, const TObject*> objects;
+    for (int index = 0; index < trackedRecords.getSize(); ++index)
+    {
+        const std::string& key = trackedRecords.getKeyAt(index);
+        const TObject* object = trackedRecords.getValueAt(index).data;
+        objects.insert(key, object);
+    }
+    return objects;
+}
+
+/*
+Function: createNewRecord
+Description: Creates a tracked record for a newly created
+             object. The record is initialized with
+             NEW_RECORD state.
+Parameters:
+    - object: Pointer to the newly created object.
+Returns:
+    - TrackedRecord<TObject>: Initialized tracked record.
+*/
+template<typename TObject>
+TrackedRecord<TObject> util::createNewRecord(TObject* object)
+{
+    TrackedRecord<TObject> record;
+    record.data = object;
+    record.state = RecordState::NEW_RECORD;
+    return record;
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/Validator.cpp

@@ -116,15 +116,13 @@ bool util::isPasswordValid(const std::string& password)
  *     usersMap - map of user objects keyed by identifier
  * Returns:
  *     bool - true if the username is already in use by an active user, false otherwise
- * Notes:
- *     - Only considers users with state util::State::ACTIVE
  */
 bool util::isUsernameDuplicate(const std::string& username, const util::Map<std::string, User*>& usersMap)
 {
     int index = usersMap.findIf(
         [&](const std::string&, User* user)
         {
-            return (user->getUserName() == username && user->getState() == util::State::ACTIVE);
+            return (user->getUserName() == username);
         }
     );
     return index != -1;

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

@@ -53,7 +53,8 @@ void AdminMenu::showMenu()
                 << "\n14. Remove Combo Package"
                 << "\n15. View Notifications"
                 << "\n16. Change Password"
-                << "\n17. Logout"
+				<< "\n17. Confirm Payment"
+                << "\n18. Logout"
                 << "\nEnter a choice: ";
             util::read(choice);
             if (!handleOperation(choice))
@@ -127,7 +128,10 @@ bool AdminMenu::handleOperation(int choice)
     case 16:
         changePassword();
         break;
-    case 17:
+	case 17:
+		confirmPayment();
+		break;
+    case 18:
         logout();
         return false;
     default:
@@ -496,6 +500,54 @@ void AdminMenu::displayUsers()
 	util::pressEnter();
 }
 
+/*
+Function: confirmPayment
+Description: Confirms payment for a selected invoice. Validates invoice status, updates payment date,
+			 sets status to COMPLETED, and sends a notification to the customer.
+Parameters:
+	- invoiceID: std::string, ID of the invoice to confirm
+Returns:
+	- void
+*/
+void AdminMenu::confirmPayment()
+{
+	util::clear();
+	std::cout << "Confirm Payment\n";
+	auto invoiceList = m_controller.getAllInvoices();
+	if (invoiceList.isEmpty())
+	{
+		std::cout << "No pending invoices available for confirmation.";
+		util::pressEnter();
+		return;
+	}
+	bool hasConfirmableInvoice = false;
+	for (int index = 0; index < invoiceList.getSize(); ++index)
+	{
+		const Invoice* invoice = invoiceList.getValueAt(index);
+		if (invoice && invoice->getStatus() == util::PaymentStatus::PAID)
+		{
+			hasConfirmableInvoice = true;
+			break;
+		}
+	}
+	if (!hasConfirmableInvoice)
+	{
+		std::cout << "No invoices awaiting confirmation.\n";
+		util::pressEnter();
+		return;
+	}
+	std::string selectedID = selectInvoiceFromUserForPayment(invoiceList, util::PaymentStatus::PAID);
+	if (selectedID == "")
+	{
+		std::cout << "Payment failed.\n";
+		util::pressEnter();
+		return;
+	}
+	m_controller.confirmPayment(selectedID);
+	std::cout << "Payment Confirmed successfully.\n";
+	util::pressEnter();
+}
+
 /*
 Function: addTechnician
 Description: Adds a new technician after validating username, password, email, and phone number.

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

@@ -28,6 +28,7 @@ public:
     void createService();
     void removeService();
     void displayUsers();
+    void confirmPayment();
     void addTechnician();
     void removeUser();
     void displayComboPackages();

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

@@ -30,7 +30,6 @@ Description: Displays the customer menu and handles user input until logout is s
 Parameter: None
 Return type: void
 */
-
 void CustomerMenu::showMenu()
 {
     while (true)
@@ -338,7 +337,7 @@ void CustomerMenu::completePayments()
         util::pressEnter();
         return;
     }
-	std::string selectedID = selectInvoiceFromUserForPayment(currentInvoices);
+	std::string selectedID = selectInvoiceFromUserForPayment(currentInvoices, util::PaymentStatus::PENDING);
     if (selectedID == "")
     {
         std::cout << "Payment failed.\n";

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

@@ -364,14 +364,18 @@ inline const User* selectTechnician(util::Map<int, const User*>& currentAvailabl
 }
 
 /*
-Function: selectInvoiceFromUserForPayment 
-Description: Lists all pending invoices for the customer and allows selection by index.
+Function: selectInvoiceFromUserForPayment
+Description: Displays a list of invoices filtered by the required payment status.
+             Allows the user to select an invoice by index and returns the corresponding invoice ID.
 Parameters:
-	- currentInvoices: util::Map<std::string, const Invoice*>&, map of customer invoices
+    - currentInvoices: const util::Map<std::string, const Invoice*>&,
+                       map of all invoices keyed by invoice ID
+    - requiredStatus: util::PaymentStatus,
+                      the status to filter invoices (e.g., PENDING, PAID, COMPLETED)
 Returns:
-	- std::string: ID of the selected invoice, or empty string if none selected
+    - std::string: ID of the selected invoice, or empty string if none selected or invalid index
 */
-inline std::string selectInvoiceFromUserForPayment(const util::Map<std::string, const Invoice*>& currentInvoices)
+inline std::string selectInvoiceFromUserForPayment(const util::Map<std::string, const Invoice*>& currentInvoices, util::PaymentStatus requiredStatus)
 {
 	int currentIndex = 1, choice;
 	util::Map<int, const Invoice*> pendingInvoicesForPayment;
@@ -389,7 +393,7 @@ inline std::string selectInvoiceFromUserForPayment(const util::Map<std::string,
 	for (int iterator = 0; iterator < currentInvoices.getSize(); iterator++)
 	{
 		const Invoice* currentInvoice = currentInvoices.getValueAt(iterator);
-		if (currentInvoice && currentInvoice->getStatus() == util::PaymentStatus::PENDING)
+		if (currentInvoice && currentInvoice->getStatus() == requiredStatus)
 {
 			const User* currentTechnician = currentInvoice->getBooking()->getAssignedTechnician();
             std::cout << std::left
@@ -627,7 +631,6 @@ inline void displayInvoices(util::Map<std::string, const Invoice*> currentUserIn
                 std::cout << "Unable to fetch the selected invoice\n";
                 doRun = false;
             }
-
         } while (doRun);
     }
 }
@@ -646,7 +649,35 @@ inline util::Map<std::string, const JobCard*> filterStartedJobCards(util::Map<st
     for (int iterator = 0; iterator  < assignedJobCards.getSize(); iterator++)
     {
         const JobCard* currentJobCard = assignedJobCards.getValueAt(iterator);
-        if (currentJobCard && currentJobCard->getStatus() == util::ServiceJobStatus::STARTED)
+        if (currentJobCard && (currentJobCard->getStatus() == util::ServiceJobStatus::STARTED || currentJobCard->getStatus() == util::ServiceJobStatus::IN_PROGRESS))
+        {
+            startedJobCards.insert(currentJobCard->getId(), currentJobCard);
+        }
+    }
+    return startedJobCards;
+}
+
+/*
+Function: filterJobCards
+Description:
+    Filters the given list of job cards and returns only those
+    whose status matches the specified ServiceJobStatus.
+Parameters:
+    - assignedJobCards: util::Map<std::string, const JobCard*>&
+        Map of job card IDs to JobCard pointers assigned to the technician.
+    - selectedJobStatus: util::ServiceJobStatus
+        The status type to filter job cards by.
+Returns:
+    - util::Map<std::string, const JobCard*>
+        A map containing only job cards with the specified status.
+*/
+inline util::Map<std::string, const JobCard*> filterJobCards(util::Map<std::string, const JobCard*>& assignedJobCards, util::ServiceJobStatus selectedJobStatus)
+{
+    util::Map<std::string, const JobCard*> startedJobCards;
+    for (int iterator = 0; iterator < assignedJobCards.getSize(); iterator++)
+    {
+        const JobCard* currentJobCard = assignedJobCards.getValueAt(iterator);
+        if (currentJobCard && currentJobCard->getStatus() == selectedJobStatus)
         {
             startedJobCards.insert(currentJobCard->getId(), currentJobCard);
         }
@@ -675,16 +706,18 @@ inline void displayAllJobs(util::Map<std::string, const JobCard*>& assignedJobCa
         << std::setw(12) << "JobID"
         << std::setw(20) << "ServiceName"
         << std::setw(12) << "ServiceID"
+        << std::setw(12) << "Status"
         << std::endl;
     for (int iterator = 0; iterator < assignedJobCards.getSize(); iterator++)
     {
         const JobCard* currentJobCard = assignedJobCards.getValueAt(iterator);
-        if (currentJobCard && (currentJobCard->getStatus() == util::ServiceJobStatus::STARTED))
+        if (currentJobCard && (currentJobCard->getStatus() == util::ServiceJobStatus::STARTED || currentJobCard->getStatus() == util::ServiceJobStatus::IN_PROGRESS))
         {
             std::cout << std::left << std::setw(12) << currentJobCard->getBookingId()
                 << std::setw(12) << currentJobCard->getId()
-                << std::setw(20) << currentJobCard->getService()->getName()
+                << std::setw(20) << util::truncateString(currentJobCard->getService()->getName(), 15)
                 << std::setw(12) << currentJobCard->getServiceId()
+                << std::setw(12) << util::getServiceJobStatusString(currentJobCard->getStatus())
                 << std::endl;
         }
     }
@@ -698,16 +731,31 @@ Parameters:
 Returns:
 	- std::string: ID of the selected job card, or empty string if none selected
 */
-inline std::string selectJobCardToComplete(util::Map<std::string, const JobCard*>& assignedJobCards)
+inline std::string selectJobCardToUpdate(util::Map<std::string, const JobCard*>& assignedJobCards,  util::ServiceJobStatus selectedJobStatusType)
 {
     util::Map<int, const JobCard* > incompleteJobCards;
     if (assignedJobCards.getSize() == 0)
     {
-        std::cout << "No started jobs available to complete.\n";
+        std::cout << "\nNo jobs available.\n\n";
         return "";
     }
     int currentIndex = 1;
     int choice;
+    if (selectedJobStatusType == util::ServiceJobStatus::STARTED)
+    {
+        util::clear();
+        std::cout << "Select a job to mark as In Progress\n";
+    }
+    else if (selectedJobStatusType == util::ServiceJobStatus::IN_PROGRESS)
+    {
+        util::clear();
+        std::cout << "Select a job to mark as Completed\n";
+    }
+    else
+    {
+        std::cout << "Unable to update completed or pending jobs.\n\n";
+        return "";
+    }
     std::cout << std::endl;
     std::cout << std::left
         << std::setw(6) << "Index"
@@ -715,22 +763,24 @@ inline std::string selectJobCardToComplete(util::Map<std::string, const JobCard*
         << std::setw(12) << "JobID"
         << std::setw(20) << "ServiceName"
         << std::setw(12) << "ServiceID"
+        << std::setw(12) << "JobStatus"
         << std::endl;
     for (int iterator = 0; iterator < assignedJobCards.getSize(); iterator++)
     {
         const JobCard* currentJobCard = assignedJobCards.getValueAt(iterator);
-        if (currentJobCard && (currentJobCard->getStatus() == util::ServiceJobStatus::STARTED))
+        if (currentJobCard && (currentJobCard->getStatus() == selectedJobStatusType))
         {
             std::cout << std::left << std::setw(6) << currentIndex
                 << std::setw(12) << currentJobCard->getBookingId()
                 << std::setw(12) << currentJobCard->getId()
-                << std::setw(20) << currentJobCard->getService()->getName()
+                << std::setw(20) << util::truncateString(currentJobCard->getService()->getName(), 15)
                 << std::setw(12) << currentJobCard->getServiceId()
+                << std::setw(12) << util::getServiceJobStatusString(currentJobCard->getStatus())
                 << std::endl;
             incompleteJobCards.insert(currentIndex++, currentJobCard);
         }
     }
-    std::cout << "Select the Job Card to complete (Index): ";
+    std::cout << "Enter the job index to update: ";
     util::read(choice);
     int selectedJobCardIndex = incompleteJobCards.find(choice);
     if (selectedJobCardIndex != -1)
@@ -741,7 +791,7 @@ inline std::string selectJobCardToComplete(util::Map<std::string, const JobCard*
     else
     {
         std::cout << "Invalid index.\n";
-        std::cout << "Failed to complete jobs.\n\n";
+        std::cout << "Failed to update job.\n\n";
         return "";
     }
 }
@@ -864,7 +914,7 @@ inline void changePasswordHelper(Controller& controller)
         util::clear();
         std::cout << "Change Password\n";
         std::cout << "Enter new password: ";
-        util::read(newPassword);
+        util::readPassword(newPassword);
         if (!util::isPasswordValid(newPassword))
         {
             std::cout << "Error: Password is not strong enough!\n";
@@ -878,7 +928,7 @@ inline void changePasswordHelper(Controller& controller)
             continue;
         }
         std::cout << "Confirm new password: ";
-        util::read(confirmedPassword);
+        util::readPassword(confirmedPassword);
         if (confirmedPassword != newPassword)
         {
             std::cout << "Passwords are different. Try again\n";

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

@@ -35,7 +35,7 @@ void TechnicianMenu::showMenu()
             util::clear();
             std::cout << "Technician Menu"
                 << "\n1. Display My Jobs"
-                << "\n2. Mark Job as Completed"
+                << "\n2. Update Job Status"
                 << "\n3. View Notifications"
                 << "\n4. Change Password"
                 << "\n5. Logout"
@@ -68,7 +68,7 @@ bool TechnicianMenu::handleOperation(int choice)
         displayJobs();
         break;
     case 2:
-        completeJob();
+        updateJobStatus();
         break;
     case 3:
         viewNotifications();
@@ -99,31 +99,50 @@ void TechnicianMenu::displayJobs()
     util::clear();
     std::cout << "My Jobs\n";
     util::Map<std::string, const JobCard*> assignedJobCards = m_controller.getJobCardsByUser();
-    util::Map<std::string, const JobCard*> startedJobCards = filterStartedJobCards(assignedJobCards);
-    displayAllJobs(startedJobCards);
+    util::Map<std::string, const JobCard*> jobCards = filterStartedJobCards(assignedJobCards);
+    displayAllJobs(jobCards);
     util::pressEnter();
 }
 
 /*
-Function: completeJob
-Description: Allows the technician to mark a selected job card as completed.
+Function: updateJobStatus
+Description: Allows the technician to update a selected job card.
              Validates selection and updates job status through the controller.
 Parameters:
     - None
 Returns:
     - void
 */
-void TechnicianMenu::completeJob()
+void TechnicianMenu::updateJobStatus()
 {
     util::clear();
-    std::cout << "Complete Job\n";
+    std::cout << "Update Job Status\n";
+    int choice;
+    std::string selectedJobID;
+    util::ServiceJobStatus selectedJobStatus = util::ServiceJobStatus::PENDING;
 	util::Map<std::string, const JobCard*> assignedJobCards = m_controller.getJobCardsByUser();
-    util::Map<std::string, const JobCard*> startedJobCards = filterStartedJobCards(assignedJobCards);
-	std::string selectedJobID = selectJobCardToComplete(startedJobCards);
+    std::cout << "Select the type of job you want to update:\n1.Started\n2.In Progress\nChoice: ";
+    util::read(choice);
+    if (choice == 1)
+    {
+        selectedJobStatus = util::ServiceJobStatus::STARTED;
+    }
+    else if (choice == 2)
+    {
+        selectedJobStatus = util::ServiceJobStatus::IN_PROGRESS;
+    }
+    else
+    {
+        std::cout << "Invalid choice. Please try again.\n";
+        util::pressEnter();
+        return;
+    }
+    util::Map<std::string, const JobCard*> selectedTypeJobCard = filterJobCards(assignedJobCards, selectedJobStatus);
+	selectedJobID = selectJobCardToUpdate(selectedTypeJobCard, selectedJobStatus);
     if (!selectedJobID.empty())
 	{
-		m_controller.completeJob(selectedJobID);
-		std::cout << "\nJob marked as completed.\n\n";
+		m_controller.updateJobStatus(selectedJobID);
+		std::cout << "\nJob status updated.\n\n";
 	}
     util::pressEnter();
 }

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

@@ -18,8 +18,8 @@ private:
 public:
     void showMenu();
     void displayJobs();
-    void completeJob();
+    void updateJobStatus();
     void viewNotifications();
     void logout();
     void changePassword();
-};
+};

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

@@ -27,8 +27,11 @@ void UserInterface::run()
 {
 	try
 	{
-		m_controller.loadSystemData();
-		m_controller.runSystemChecks();
+		if (!m_controller.initialize())
+		{
+			std::cout << "Error: Failed to initialize the system!";
+			return;
+		}
 		bool isMenuActive = true;
 		while (isMenuActive)
 		{
@@ -49,7 +52,7 @@ void UserInterface::run()
 				util::pressEnter();
 			}
 		}
-		m_controller.saveSystemData();
+		m_controller.shutdown();
 	}
 	catch (const std::invalid_argument& exception)
 	{
@@ -106,7 +109,7 @@ void UserInterface::login()
 	std::cout << "Enter username: ";
 	util::read(username);
 	std::cout << "Enter password: ";
-	util::read(password);
+	util::readPassword(password);
 	if (m_controller.login(username, password))
 	{
 		const User* authenticatedUser = m_controller.getAuthenticatedUser();
@@ -167,7 +170,7 @@ void UserInterface::registerCustomer()
 		return;
 	}
 	std::cout << "Enter password: ";
-	util::read(password);
+	util::readPassword(password);
 	if (!util::isPasswordValid(password))
 	{
 		std::cout << "Error: Password is invalid!";
@@ -185,4 +188,4 @@ void UserInterface::registerCustomer()
 	m_controller.createCustomer(username, name, password, email, phone);
 	std::cout << "Registration is successful";
 	util::pressEnter();
-}
+}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/UserInterface.h

@@ -27,4 +27,4 @@ public:
     void run();
     void login();
     void registerCustomer();
-};
+};