Implement review fixes

<UserStory> 1960: Service Refactoring </UserStory>

UserStory #1960

<Changes>
1. Replaced the Controller load/save workflow with initialize() and shutdown() methods.
2. Moved startup checks such as admin verification, low stock alerts, and payment reminders into Controller::initialize().
3. Updated UserInterface to use the new Controller initialization and shutdown flow.
4. Updated DataStore::getUsers() and DataStore::getNotifications() to load data directly from shared memory.
5. Added logic to rebuild user notification mappings when user data is loaded from shared memory.
6. Implemented user and notification persistence through DataStore::saveUsers() and DataStore::saveNotifications().
7. Updated UserManagementService to use TrackedRecord-based shared memory records.
8. Added DataStore locking and unlocking to user management operations for synchronization.
9. Updated createUser(), updateUserDetails(), removeUser(), and deleteNotification() to persist changes through shared memory.
10. Removed legacy loadUsers() and saveUsers() implementations from UserManagementService.
11. Added required header dependencies for shared memory support.
</Changes>

<Test>
N/A
</Test>

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

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

@@ -157,6 +157,7 @@
     <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" />

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"
@@ -587,63 +588,37 @@ void Controller::configureNotifications(bool paymentNotifications, bool serviceN
 }
 
 /*
-Function: loadSystemData
+Function: initialize
-Description: Loads all system data from persistent storage into memory.
+Description: Initializes the system and run system checks to ensure critical configurations, such as verifying admin existence.
-             Invokes the respective management services to load users, inventory items, services,
-             combo packages, service bookings, job cards, invoices, and observers.
 Parameters:
     - None
 Returns:
-    - void
+    - bool
 */
-void Controller::loadSystemData()
+bool Controller::initialize()
 {
-    m_userManagementService.loadUsers();
+    auto& dataStore = DataStore::getInstance();
-    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();
-}
 
-/*
+    if (!dataStore.initialize())
-Function: saveSystemData
+    {
-Description: Saves all system data from memory back to persistent storage.
+        return false;
-             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()
-{
     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

@@ -70,7 +70,6 @@ public:
     util::Vector<const Notification*> getNotifications();
     void deleteNotification(const std::string& notificationID);
     void configureNotifications(bool paymentNotifications, bool serviceNotifications);
-    void loadSystemData();
+    bool initialize();
-    void saveSystemData();
+    void shutdown();
-    void runSystemChecks();
 };

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

@@ -13,9 +13,42 @@ Date: 19-May-2026
 #include "SerializedRecords.h"
 #include "FileHelper.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.
@@ -38,78 +71,106 @@ bool DataStore::initialize()
     {
         return false;
     }
-    util::ensureDirectoryExists(config::file::DIRECTORY);
+    if (!lockDataStore())
-    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))
     {
+        CloseHandle(m_globalMutex);
+        m_globalMutex = NULL;
         return false;
     }
-    if (!SharedMemory::createOrOpenMapping(m_notifications))
+    bool success = true;
+    do
     {
-        return false;
+        util::ensureDirectoryExists(config::file::DIRECTORY);
-    }
+        m_users.fileName = config::file::USER_FILE;
-    if (!SharedMemory::createOrOpenMapping(m_services))
+        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_payments))
+        {
+            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)
     {
-        return false;
+        shutdown();
     }
-    if (!SharedMemory::createOrOpenMapping(m_comboPackages))
+    return success;
-    {
-        return false;
-    }
-    if (!SharedMemory::createOrOpenMapping(m_inventoryItems))
-    {
-        return false;
-    }
-    if (!SharedMemory::createOrOpenMapping(m_serviceBookings))
-    {
-        return false;
-    }
-    if (!SharedMemory::createOrOpenMapping(m_jobCards))
-    {
-        return false;
-    }
-    if (!SharedMemory::createOrOpenMapping(m_invoices))
-    {
-        return false;
-    }
-    if (!SharedMemory::createOrOpenMapping(m_payments))
-    {
-        return false;
-    }
-    if (!SharedMemory::createOrOpenMapping(m_serviceManagementObservers))
-    {
-        return false;
-    }
-    if (!SharedMemory::createOrOpenMapping(m_paymentManagementObservers))
-    {
-        return false;
-    }
-    if (!SharedMemory::createOrOpenMapping(m_inventoryManagementObservers))
-    {
-        return false;
-    }
-    return true;
 }
 
 /*
@@ -165,9 +226,25 @@ Parameters:
 Returns:
     - util::Map<std::string, TrackedRecord<User>>: Collection of user records
 */
-util::Map<std::string, TrackedRecord<User>> DataStore::getUsers()
+util::Map<std::string, TrackedRecord<User>>& DataStore::getUsers()
 {
-    return util::Map<std::string, TrackedRecord<User>>();
+    auto users = loadRecords<User, SerializedUser>(m_users);
+    refreshCache(m_userCache, users);
+    auto& notifications = getNotifications();
+    int numberOfNotifications = m_notificationCache.getSize();
+    for (int index = 0; index < numberOfNotifications; index++)
+    {
+        Notification* notification = notifications.getValueAt(index).data;
+        const std::string& recipientUserId = notification->getRecipientUserId();
+        int userIndex = m_userCache.find(recipientUserId);
+        if (userIndex == -1)
+        {
+            throw std::runtime_error("Invalid recipient user ID");
+        }
+        User* user = m_userCache.getValueAt(userIndex).data;
+        user->addNotification(notification);
+    }
+    return m_userCache;
 }
 
 /*
@@ -178,9 +255,11 @@ Parameters:
 Returns:
     - util::Map<std::string, TrackedRecord<Notification>>: Collection of notification records
 */
-util::Map<std::string, TrackedRecord<Notification>> DataStore::getNotifications()
+util::Map<std::string, TrackedRecord<Notification>>& DataStore::getNotifications()
 {
-    return util::Map<std::string, TrackedRecord<Notification>>();
+    auto notifications = loadRecords<Notification, SerializedNotification>(m_notifications);
+    refreshCache(m_notificationCache, notifications);
+    return m_notificationCache;
 }
 
 /*
@@ -191,9 +270,9 @@ Parameters:
 Returns:
     - util::Map<std::string, TrackedRecord<Service>>: Collection of service records
 */
-util::Map<std::string, TrackedRecord<Service>> DataStore::getServices()
+util::Map<std::string, TrackedRecord<Service>>& DataStore::getServices()
 {
-    return util::Map<std::string, TrackedRecord<Service>>();
+    return m_serviceCache;
 }
 
 /*
@@ -204,9 +283,9 @@ Parameters:
 Returns:
     - util::Map<std::string, TrackedRecord<ComboPackage>>: Collection of combo package records
 */
-util::Map<std::string, TrackedRecord<ComboPackage>> DataStore::getComboPackages()
+util::Map<std::string, TrackedRecord<ComboPackage>>& DataStore::getComboPackages()
 {
-    return util::Map<std::string, TrackedRecord<ComboPackage>>();
+    return m_comboPackageCache;
 }
 
 /*
@@ -217,9 +296,9 @@ Parameters:
 Returns:
     - util::Map<std::string, TrackedRecord<InventoryItem>>: Collection of inventory item records
 */
-util::Map<std::string, TrackedRecord<InventoryItem>> DataStore::getInventoryItems()
+util::Map<std::string, TrackedRecord<InventoryItem>>& DataStore::getInventoryItems()
 {
-    return util::Map<std::string, TrackedRecord<InventoryItem>>();
+    return m_inventoryItemCache;
 }
 
 /*
@@ -230,9 +309,9 @@ Parameters:
 Returns:
     - util::Map<std::string, TrackedRecord<ServiceBooking>>: Collection of service booking records
 */
-util::Map<std::string, TrackedRecord<ServiceBooking>> DataStore::getServiceBookings()
+util::Map<std::string, TrackedRecord<ServiceBooking>>& DataStore::getServiceBookings()
 {
-    return util::Map<std::string, TrackedRecord<ServiceBooking>>();
+    return m_serviceBookingCache;
 }
 
 /*
@@ -243,9 +322,9 @@ Parameters:
 Returns:
     - util::Map<std::string, TrackedRecord<JobCard>>: Collection of job card records
 */
-util::Map<std::string, TrackedRecord<JobCard>> DataStore::getJobCards()
+util::Map<std::string, TrackedRecord<JobCard>>& DataStore::getJobCards()
 {
-    return util::Map<std::string, TrackedRecord<JobCard>>();
+    return m_jobCardCache;
 }
 
 /*
@@ -256,22 +335,9 @@ Parameters:
 Returns:
     - util::Map<std::string, TrackedRecord<Invoice>>: Collection of invoice records
 */
-util::Map<std::string, TrackedRecord<Invoice>> DataStore::getInvoices()
+util::Map<std::string, TrackedRecord<Invoice>>& DataStore::getInvoices()
 {
-    return util::Map<std::string, TrackedRecord<Invoice>>();
+    return m_invoiceCache;
-}
-
-/*
-Function: getPayments
-Description: Retrieves all payment records from the datastore.
-Parameters:
-    - None
-Returns:
-    - util::Map<std::string, TrackedRecord<Payment>>: Collection of payment records
-*/
-util::Map<std::string, TrackedRecord<Payment>> DataStore::getPayments()
-{
-    return util::Map<std::string, TrackedRecord<Payment>>();
 }
 
 /*
@@ -280,11 +346,11 @@ Description: Retrieves all service management observer records from the datastor
 Parameters:
     - None
 Returns:
-    - util::Map<std::string, TrackedRecord<std::string>>: Collection of observer records
+    - util::Map<std::string, User*>: Collection of observer records
 */
-util::Map<std::string, TrackedRecord<std::string>> DataStore::getServiceManagementObservers()
+util::Map<std::string, User*> DataStore::getServiceManagementObservers()
 {
-    return util::Map<std::string, TrackedRecord<std::string>>();
+    return util::Map<std::string, User*>();
 }
 
 /*
@@ -293,11 +359,11 @@ Description: Retrieves all payment management observer records from the datastor
 Parameters:
     - None
 Returns:
-    - util::Map<std::string, TrackedRecord<std::string>>: Collection of observer records
+    - util::Map<std::string, User*>: Collection of observer records
 */
-util::Map<std::string, TrackedRecord<std::string>> DataStore::getPaymentManagementObservers()
+util::Map<std::string, User*> DataStore::getPaymentManagementObservers()
 {
-    return util::Map<std::string, TrackedRecord<std::string>>();
+    return util::Map<std::string, User*>();
 }
 
 /*
@@ -306,46 +372,49 @@ Description: Retrieves all inventory management observer records from the datast
 Parameters:
     - None
 Returns:
-    - util::Map<std::string, TrackedRecord<std::string>>: Collection of observer records
+    - util::Map<std::string, User*>: Collection of observer records
 */
-util::Map<std::string, TrackedRecord<std::string>> DataStore::getInventoryManagementObservers()
+util::Map<std::string, User*> DataStore::getInventoryManagementObservers()
 {
-    return util::Map<std::string, TrackedRecord<std::string>>();
+    return util::Map<std::string, User*>();
 }
 
 /*
 Function: saveUsers
 Description: Persists all user records to the datastore.
 Parameters:
-    - users: util::Map<std::string, TrackedRecord<User>>&, collection of user records
+    - None
 Returns:
     - None
 */
-void DataStore::saveUsers(util::Map<std::string, TrackedRecord<User>>& users)
+void DataStore::saveUsers()
 {
+    saveRecords<User, SerializedUser>(m_users, m_userCache);
+    saveNotifications();
 }
 
 /*
 Function: saveNotifications
 Description: Persists all notification records to the datastore.
 Parameters:
-    - notifications: util::Map<std::string, TrackedRecord<Notification>>&, collection of notification records
+    - None
 Returns:
     - None
 */
-void DataStore::saveNotifications(util::Map<std::string, TrackedRecord<Notification>>& notifications)
+void DataStore::saveNotifications()
 {
+    saveRecords<Notification, SerializedNotification>(m_notifications, m_notificationCache);
 }
 
 /*
 Function: saveServices
 Description: Persists all service records to the datastore.
 Parameters:
-    - services: util::Map<std::string, TrackedRecord<Service>>&, collection of service records
+    - None
 Returns:
     - None
 */
-void DataStore::saveServices(util::Map<std::string, TrackedRecord<Service>>& services)
+void DataStore::saveServices()
 {
 }
 
@@ -353,11 +422,11 @@ void DataStore::saveServices(util::Map<std::string, TrackedRecord<Service>>& ser
 Function: saveComboPackages
 Description: Persists all combo package records to the datastore.
 Parameters:
-    - comboPackages: util::Map<std::string, TrackedRecord<ComboPackage>>&, collection of combo package records
+    - None
 Returns:
     - None
 */
-void DataStore::saveComboPackages(util::Map<std::string, TrackedRecord<ComboPackage>>& comboPackages)
+void DataStore::saveComboPackages()
 {
 }
 
@@ -365,11 +434,11 @@ void DataStore::saveComboPackages(util::Map<std::string, TrackedRecord<ComboPack
 Function: saveInventoryItems
 Description: Persists all inventory item records to the datastore.
 Parameters:
-    - inventoryItems: util::Map<std::string, TrackedRecord<InventoryItem>>&, collection of inventory item records
+    - None
 Returns:
     - None
 */
-void DataStore::saveInventoryItems(util::Map<std::string, TrackedRecord<InventoryItem>>& inventoryItems)
+void DataStore::saveInventoryItems()
 {
 }
 
@@ -377,11 +446,11 @@ void DataStore::saveInventoryItems(util::Map<std::string, TrackedRecord<Inventor
 Function: saveServiceBookings
 Description: Persists all service booking records to the datastore.
 Parameters:
-    - bookings: util::Map<std::string, TrackedRecord<ServiceBooking>>&, collection of service booking records
+    - None
 Returns:
     - None
 */
-void DataStore::saveServiceBookings(util::Map<std::string, TrackedRecord<ServiceBooking>>& bookings)
+void DataStore::saveServiceBookings()
 {
 }
 
@@ -389,11 +458,11 @@ void DataStore::saveServiceBookings(util::Map<std::string, TrackedRecord<Service
 Function: saveJobCards
 Description: Persists all job card records to the datastore.
 Parameters:
-    - jobCards: util::Map<std::string, TrackedRecord<JobCard>>&, collection of job card records
+    - None
 Returns:
     - None
 */
-void DataStore::saveJobCards(util::Map<std::string, TrackedRecord<JobCard>>& jobCards)
+void DataStore::saveJobCards()
 {
 }
 
@@ -401,23 +470,11 @@ void DataStore::saveJobCards(util::Map<std::string, TrackedRecord<JobCard>>& job
 Function: saveInvoices
 Description: Persists all invoice records to the datastore.
 Parameters:
-    - invoices: util::Map<std::string, TrackedRecord<Invoice>>&, collection of invoice records
+    - None
 Returns:
     - None
 */
-void DataStore::saveInvoices(util::Map<std::string, TrackedRecord<Invoice>>& invoices)
+void DataStore::saveInvoices()
-{
-}
-
-/*
-Function: savePayments
-Description: Persists all payment records to the datastore.
-Parameters:
-    - payments: util::Map<std::string, TrackedRecord<Payment>>&, collection of payment records
-Returns:
-    - None
-*/
-void DataStore::savePayments(util::Map<std::string, TrackedRecord<Payment>>& payments)
 {
 }
 
@@ -429,7 +486,7 @@ Parameters:
 Returns:
     - None
 */
-void DataStore::saveServiceManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers)
+void DataStore::saveServiceManagementObservers(util::Map<std::string, User*>& observers)
 {
 }
 
@@ -437,11 +494,11 @@ void DataStore::saveServiceManagementObservers(util::Map<std::string, TrackedRec
 Function: savePaymentManagementObservers
 Description: Persists all payment management observer records to the datastore.
 Parameters:
-    - observers: util::Map<std::string, TrackedRecord<std::string>>&, collection of observer records
+    - observers: util::Map<std::string, User*>&, collection of observer records
 Returns:
     - None
 */
-void DataStore::savePaymentManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers)
+void DataStore::savePaymentManagementObservers(util::Map<std::string, User*>& observers)
 {
 }
 
@@ -449,11 +506,11 @@ void DataStore::savePaymentManagementObservers(util::Map<std::string, TrackedRec
 Function: saveInventoryManagementObservers
 Description: Persists all inventory management observer records to the datastore.
 Parameters:
-    - observers: util::Map<std::string, TrackedRecord<std::string>>&, collection of observer records
+    - observers: util::Map<std::string, User*>&, collection of observer records
 Returns:
     - None
 */
-void DataStore::saveInventoryManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers)
+void DataStore::saveInventoryManagementObservers(util::Map<std::string, User*>& observers)
 {
 }
 
@@ -526,3 +583,4 @@ bool DataStore::unlockDataStore()
     }
     return ReleaseMutex(m_globalMutex) != 0;
 }
+

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

@@ -20,12 +20,12 @@ class InventoryItem;
 class ServiceBooking;
 class JobCard;
 class Invoice;
-class Payment;
 
 class DataStore
 {
 private:
     DataStore();
+    ~DataStore();
     DataStore(const DataStore&) = delete;
     DataStore& operator=(const DataStore&) = delete;
     DataStore(DataStore&&) = delete;
@@ -43,34 +43,40 @@ private:
     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<User>>& getUsers();
-    util::Map<std::string, TrackedRecord<Notification>> getNotifications();
+    util::Map<std::string, TrackedRecord<Notification>>& getNotifications();
-    util::Map<std::string, TrackedRecord<Service>> getServices();
+    util::Map<std::string, TrackedRecord<Service>>& getServices();
-    util::Map<std::string, TrackedRecord<ComboPackage>> getComboPackages();
+    util::Map<std::string, TrackedRecord<ComboPackage>>& getComboPackages();
-    util::Map<std::string, TrackedRecord<InventoryItem>> getInventoryItems();
+    util::Map<std::string, TrackedRecord<InventoryItem>>& getInventoryItems();
-    util::Map<std::string, TrackedRecord<ServiceBooking>> getServiceBookings();
+    util::Map<std::string, TrackedRecord<ServiceBooking>>& getServiceBookings();
-    util::Map<std::string, TrackedRecord<JobCard>> getJobCards();
+    util::Map<std::string, TrackedRecord<JobCard>>& getJobCards();
-    util::Map<std::string, TrackedRecord<Invoice>> getInvoices();
+    util::Map<std::string, TrackedRecord<Invoice>>& getInvoices();
-    util::Map<std::string, TrackedRecord<Payment>> getPayments();
+    util::Map<std::string, User*> getServiceManagementObservers();
-    util::Map<std::string, TrackedRecord<std::string>> getServiceManagementObservers();
+    util::Map<std::string, User*> getPaymentManagementObservers();
-    util::Map<std::string, TrackedRecord<std::string>> getPaymentManagementObservers();
+    util::Map<std::string, User*> getInventoryManagementObservers();
-    util::Map<std::string, TrackedRecord<std::string>> getInventoryManagementObservers();
+    void saveUsers();
-    void saveUsers(util::Map<std::string, TrackedRecord<User>>& users);
+    void saveNotifications();
-    void saveNotifications(util::Map<std::string, TrackedRecord<Notification>>& notifications);
+    void saveServices();
-    void saveServices(util::Map<std::string, TrackedRecord<Service>>& services);
+    void saveComboPackages();
-    void saveComboPackages(util::Map<std::string, TrackedRecord<ComboPackage>>& comboPackages);
+    void saveInventoryItems();
-    void saveInventoryItems(util::Map<std::string, TrackedRecord<InventoryItem>>& inventoryItems);
+    void saveServiceBookings();
-    void saveServiceBookings(util::Map<std::string, TrackedRecord<ServiceBooking>>& bookings);
+    void saveJobCards();
-    void saveJobCards(util::Map<std::string, TrackedRecord<JobCard>>& jobCards);
+    void saveInvoices();
-    void saveInvoices(util::Map<std::string, TrackedRecord<Invoice>>& invoices);
+    void saveServiceManagementObservers(util::Map<std::string, User*>& observers);
-    void savePayments(util::Map<std::string, TrackedRecord<Payment>>& payments);
+    void savePaymentManagementObservers(util::Map<std::string, User*>& observers);
-    void saveServiceManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers);
+    void saveInventoryManagementObservers(util::Map<std::string, User*>& observers);
-    void savePaymentManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers);
-    void saveInventoryManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers);
     bool lockDataStore();
     bool unlockDataStore();
 private:
@@ -78,6 +84,8 @@ private:
     util::Map<std::string, TrackedRecord<TObject>> loadRecords(MappingInfo& mapping);
     template<typename TObject, typename TSerialized>
     void saveRecords(MappingInfo& mapping, util::Map<std::string, TrackedRecord<TObject>>& records);
+    template<typename TObject> void clearCache(util::Map<std::string, TrackedRecord<TObject>>&cache);
+    template<typename TObject> void refreshCache(util::Map<std::string, TrackedRecord<TObject>>&cache, util::Map<std::string, TrackedRecord<TObject>>&refreshedCache);
 };
 
 /*
@@ -123,9 +131,7 @@ Description: Persists all modified and newly added records
              shared-memory mapping. Modified records overwrite
              their existing slots, while new records are
              appended to the end of the mapping. Records marked
-             as CLEAN are ignored. After persistence, all
+             as CLEAN are ignored.
-             temporary objects owned by the tracked records are
-             destroyed to release memory.
 Parameter:
     - mapping: Reference to the mapping where records are
                stored.
@@ -158,14 +164,74 @@ template<typename TObject, typename TSerialized> void DataStore::saveRecords(Map
                 continue;
             }
             size_t recordCount = SharedMemory::getRecordCount(mapping);
-            TSerialized* destination = static_cast<TSerialized*>(SharedMemory::getRecordAddress(mapping, recordCount));
+            TSerialized* destination = static_cast<TSerialized*>(SharedMemory::getRecordAddress(mapping,recordCount));
             *destination = serialized;
             SharedMemory::setRecordCount(mapping, recordCount + 1);
+            record.slotIndex = recordCount;
+        }
+        record.state = RecordState::CLEAN;
+    }
+}
+
+/*
+Function: clearCache
+Description: Releases all objects owned by the cache and
+             clears the cache contents.
+Parameters:
+    - cache: Cache to be cleared.
+Returns:
+    - None
+*/
+template<typename TObject>
+void DataStore::clearCache(util::Map<std::string, TrackedRecord<TObject>>&cache)
+{
+    for (int index = 0; index < cache.getSize(); ++index)
+    {
+        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);
+        if (cache.find(id) == -1)
+        {
+            delete oldCache.getValueAt(index).data;
         }
-    }
-    for (int index = 0; index < records.getSize(); ++index)
-    {
-        delete records.getValueAt(index).data;
-        records.getValueAt(index).data = nullptr;
     }
 }

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

@@ -1,3 +1,12 @@
+/*
+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>
 

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

@@ -1,3 +1,13 @@
+/*
+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>

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

@@ -1,3 +1,12 @@
+/*
+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

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

@@ -1,3 +1,15 @@
+/*
+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"

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

@@ -1,4 +1,16 @@
+/*
+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"
 
 /*

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

@@ -1,3 +1,14 @@
+/*
+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"

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

@@ -1,3 +1,13 @@
+/*
+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"
 

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

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

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

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

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

@@ -8,7 +8,6 @@ Date: 19-May-2026
 
 #include <sstream>
 #include <stdexcept>
-#include "SerializedRecords.h"
 #include "Factory.h"
 #include "StringHelper.h"
 #include "InventoryItem.h"
@@ -207,37 +206,73 @@ void InventoryItem::setState(util::State status)
 
 /*
 Function: serialize
-Description: Serializes the InventoryItem object into a SerializedInventoryItem record.
+Description: Serializes the inventory item into a CSV-formatted string.
 Parameters:
     - None
 Returns:
-    - SerializedInventoryItem: Serialized representation of the inventory item
+    - std::string: Serialized inventory item record
 */
-SerializedInventoryItem InventoryItem::serialize() const
+std::string InventoryItem::serialize() const
 {
-    SerializedInventoryItem serialized = {};
+    std::ostringstream serializedInventoryItem;
-    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
+    serializedInventoryItem << m_id << ','
-    strcpy_s(serialized.partName, sizeof(serialized.partName), m_partName.c_str());
+        << m_partName << ','
-    serialized.quantity = m_quantity;
+        << m_quantity << ','
-    serialized.price = m_price;
+        << m_price << ','
-    serialized.status = m_status;
+        << util::getStateString(m_status);
-    return serialized;
+    return serializedInventoryItem.str();
 }
 
 /*
 Function: deserialize
-Description: Deserializes a SerializedInventoryItem record into an InventoryItem object.
+Description: Deserializes a CSV-formatted string into an InventoryItem object.
 Parameters:
-    - serializedInventoryItem: const SerializedInventoryItem&, serialized inventory item record
+    - record: const std::string&, serialized inventory item record
 Returns:
     - InventoryItem*: Pointer to the deserialized InventoryItem object
+Throws:
+    - std::runtime_error if data is invalid
 */
-InventoryItem* InventoryItem::deserialize(const SerializedInventoryItem& serializedInventoryItem)
+InventoryItem* InventoryItem::deserialize(const std::string& record)
 {
+    std::string id, partName;
+    std::string quantityString, priceString, statusString;
+    int quantity;
+    double price;
+    std::istringstream serializedInventoryItem(record);
+    getline(serializedInventoryItem, id, ',');
+    getline(serializedInventoryItem, partName, ',');
+    getline(serializedInventoryItem, quantityString, ',');
+    getline(serializedInventoryItem, priceString, ',');
+    getline(serializedInventoryItem, statusString, ',');
+    try
+    {
+        quantity = std::stoi(quantityString);
+        price = std::stod(priceString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid inventory item data");
+    }
+    util::State status = util::getState(statusString);
     return Factory::getObject<InventoryItem>(
-        serializedInventoryItem.id,
+        id,
-        serializedInventoryItem.partName,
+        partName,
-        serializedInventoryItem.quantity,
+        quantity,
-        serializedInventoryItem.price,
+        price,
-        serializedInventoryItem.status);
+        status
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for inventory item serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,PartName,Quantity,Price,Status")
+*/
+std::string InventoryItem::getHeaders()
+{
+    return "ID,PartName,Quantity,Price,Status";
 }

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

@@ -6,12 +6,11 @@ Author: Trenser
 Date: 19-May-2026
 */
 
+
 #pragma once
 #include <string>
 #include "Enums.h"
 
-struct SerializedInventoryItem;
-
 class InventoryItem
 {
 private:
@@ -35,6 +34,7 @@ public:
     void setQuantity(int quantity);
     void setPrice(double price);
     void setState(util::State status);
-    SerializedInventoryItem serialize() const;
+    std::string serialize() const;
-    static InventoryItem* deserialize(const SerializedInventoryItem&);
+    static InventoryItem* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

@@ -9,7 +9,6 @@ Date: 19-May-2026
 
 #include <sstream>
 #include <stdexcept>
-#include "SerializedRecords.h"
 #include "Invoice.h"
 #include "Factory.h"
 #include "InventoryItem.h"
@@ -474,50 +473,100 @@ static util::Vector<std::string> getPartIDsAsVector(const std::string& partIDsSt
 
 /*
 Function: serialize
-Description: Serializes the Invoice object into a SerializedInvoice record.
+Description: Serializes the invoice into a CSV-formatted string.
 Parameters:
     - None
 Returns:
-    - SerializedInvoice: Serialized representation of the invoice
+    - std::string: Serialized invoice record
 */
-SerializedInvoice Invoice::serialize() const
+std::string Invoice::serialize() const
 {
-    SerializedInvoice serialized = {};
+    std::ostringstream serializedInvoice;
-    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
+    serializedInvoice << m_id << ','
-    strcpy_s(serialized.bookingId, sizeof(serialized.bookingId), m_bookingId.c_str());
+        << m_bookingId << ','
-    strcpy_s(serialized.partIDs, sizeof(serialized.partIDs), getPartIDsAsString(m_partIDs).c_str());
+        << m_invoiceDate.toString() << ','
-    serialized.invoiceDate = m_invoiceDate;
+        << m_laborCost << ','
-    serialized.laborCost = m_laborCost;
+        << getPartIDsAsString(m_partIDs) << ','
-    serialized.partsCost = m_partsCost;
+        << m_partsCost << ','
-    serialized.discountPercentage = m_discountPercentage;
+        << m_discountPercentage << ','
-    serialized.totalAmount = m_totalAmount;
+        << m_totalAmount << ','
-    serialized.paymentDate = m_paymentDate;
+        << m_paymentDate.toString() << ','
-    serialized.paymentMethod = m_paymentMethod;
+        << util::getPaymentModeString(m_paymentMethod) << ','
-    serialized.status = m_status;
+        << util::getPaymentStatusString(m_status);
-    return serialized;
+    return serializedInvoice.str();
 }
 
 /*
 Function: deserialize
-Description: Deserializes a SerializedInvoice record into an Invoice object.
+Description: Deserializes a CSV-formatted string into an Invoice object.
 Parameters:
-    - serializedInvoice: const SerializedInvoice&, serialized invoice record
+    - record: const std::string&, serialized invoice record
 Returns:
     - Invoice*: Pointer to the deserialized Invoice object
+Throws:
+    - std::runtime_error if data is invalid
 */
-Invoice* Invoice::deserialize(const SerializedInvoice& serializedInvoice)
+Invoice* Invoice::deserialize(const std::string& record)
 {
-    util::Vector<std::string> partIDs = getPartIDsAsVector(serializedInvoice.partIDs);
+    std::string id, bookingId;
+    std::string invoiceDateString, laborCostString, partIDsString;
+    std::string partsCostString, discountPercentageString, totalAmountString;
+    std::string paymentDateString, paymentMethodString, statusString;
+    double laborCost, partsCost, discountPercentage, totalAmount;
+    std::istringstream serializedInvoice(record);
+    getline(serializedInvoice, id, ',');
+    getline(serializedInvoice, bookingId, ',');
+    getline(serializedInvoice, invoiceDateString, ',');
+    getline(serializedInvoice, laborCostString, ',');
+    getline(serializedInvoice, partIDsString, ',');
+    getline(serializedInvoice, partsCostString, ',');
+    getline(serializedInvoice, discountPercentageString, ',');
+    getline(serializedInvoice, totalAmountString, ',');
+    getline(serializedInvoice, paymentDateString, ',');
+    getline(serializedInvoice, paymentMethodString, ',');
+    getline(serializedInvoice, statusString, ',');
+    util::Timestamp invoiceDate;
+    util::Timestamp paymentDate;
+    try
+    {
+        invoiceDate = util::Timestamp::fromString(invoiceDateString);
+        paymentDate = util::Timestamp::fromString(paymentDateString);
+        laborCost = std::stod(laborCostString);
+        partsCost = std::stod(partsCostString);
+        discountPercentage = std::stod(discountPercentageString);
+        totalAmount = std::stod(totalAmountString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid invoice data");
+    }
+    util::Vector<std::string> partIDs = getPartIDsAsVector(partIDsString);
+    util::PaymentMode paymentMethod = util::getPaymentMode(paymentMethodString);
+    util::PaymentStatus status = util::getPaymentStatus(statusString);
     return Factory::getObject<Invoice>(
-        serializedInvoice.id,
+        id,
-        serializedInvoice.bookingId,
+        bookingId,
-        serializedInvoice.invoiceDate,
+        invoiceDate,
         partIDs,
-        serializedInvoice.laborCost,
+        laborCost,
-        serializedInvoice.partsCost,
+        partsCost,
-        serializedInvoice.discountPercentage,
+        discountPercentage,
-        serializedInvoice.totalAmount,
+        totalAmount,
-        serializedInvoice.paymentDate,
+        paymentDate,
-        serializedInvoice.paymentMethod,
+        paymentMethod,
-        serializedInvoice.status);
+        status
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for invoice serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,BookingID,InvoiceDate,LaborCost,PartIDs,PartsCost,DiscountPercentage,TotalAmount,PaymentDate,PaymentMethod,Status")
+*/
+std::string Invoice::getHeaders()
+{
+    return "ID,BookingID,InvoiceDate,LaborCost,PartIDs,PartsCost,DiscountPercentage,TotalAmount,PaymentDate,PaymentMethod,Status";
 }

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

@@ -16,7 +16,6 @@ Date: 19-May-2026
 
 class ServiceBooking;
 class InventoryItem;
-struct SerializedInvoice;
 
 class Invoice
 {
@@ -88,6 +87,7 @@ public:
     void setPaymentDate(const util::Timestamp& paymentDate);
     void setPaymentMethod(util::PaymentMode paymentMethod);
     void setStatus(util::PaymentStatus status);
-    SerializedInvoice serialize() const;
+    std::string serialize() const;
-    static Invoice* deserialize(const SerializedInvoice&);
+    static Invoice* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

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

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

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

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

@@ -7,7 +7,6 @@ Date: 19-May-2026
 */
 
 #include <sstream>
-#include "SerializedRecords.h"
 #include "Notification.h"
 #include "StringHelper.h"
 #include "Factory.h"
@@ -24,7 +23,7 @@ Returns:
 */
 Notification::Notification()
     : m_id("NOT" + std::to_string(++m_uid)),
-    m_recipient(nullptr), m_state(util::State::ACTIVE) {}
+    m_recipient(nullptr) {}
 
 /*
 Function: Notification
@@ -44,8 +43,7 @@ Notification::Notification(const std::string& recipientUserId, User* recipient,
     m_recipient(recipient),
     m_title(title),
     m_message(message),
-    m_state(util::State::ACTIVE),
+    m_createdAt(createdAt) {}
-    m_createdAt(createdAt){}
 
 /*
 Function: Notification (parameterized constructor with ID)
@@ -60,14 +58,13 @@ Parameters:
 Returns:
     - A new Notification object
 */
-Notification::Notification(const std::string& id, const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt, const util::State& state)
+Notification::Notification(const std::string& id, const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt)
     : m_id(id),
     m_recipientUserId(recipientUserId),
     m_recipient(nullptr),
     m_title(title),
     m_message(message),
-    m_createdAt(createdAt),
+    m_createdAt(createdAt) 
-    m_state(state)
 {
     int idNumber = util::extractNumber(m_id);
     if (idNumber > m_uid)
@@ -222,39 +219,69 @@ void Notification::setCreatedAt(const util::Timestamp& createdAt)
 
 /*
 Function: serialize
-Description: Serializes the Notification object into a SerializedNotification record.
+Description: Serializes the notification into a CSV-formatted string.
 Parameters:
     - None
 Returns:
-    - SerializedNotification: Serialized representation of the notification
+    - std::string: Serialized notification record
 */
-SerializedNotification Notification::serialize() const
+std::string Notification::serialize() const
 {
-    SerializedNotification serialized = {};
+    std::ostringstream serializedNotification;
-    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
+    serializedNotification << m_id << ','
-    strcpy_s(serialized.recipientUserId, sizeof(serialized.recipientUserId), m_recipientUserId.c_str());
+        << m_recipientUserId << ','
-    strcpy_s(serialized.title, sizeof(serialized.title), m_title.c_str());
+        << m_title << ','
-    strcpy_s(serialized.message, sizeof(serialized.message), m_message.c_str());
+        << m_message << ','
-    serialized.createdAt = m_createdAt;
+        << m_createdAt.toString();
-    serialized.state = m_state;
+    return serializedNotification.str();
-    return serialized;
 }
 
 /*
 Function: deserialize
-Description: Deserializes a SerializedNotification record into a Notification object.
+Description: Deserializes a CSV-formatted string into a Notification object.
 Parameters:
-    - serializedNotification: const SerializedNotification&, serialized notification record
+    - record: const std::string&, serialized notification record
 Returns:
     - Notification*: Pointer to the deserialized Notification object
+Throws:
+    - std::runtime_error if timestamp parsing fails
 */
-Notification* Notification::deserialize(const SerializedNotification& serializedNotification)
+Notification* Notification::deserialize(const std::string& record)
 {
+    std::string id, recipientUserId, title, message, createdAtTimestampString;
+    std::istringstream serializedNotification(record);
+    getline(serializedNotification, id, ',');
+    getline(serializedNotification, recipientUserId, ',');
+    getline(serializedNotification, title, ',');
+    getline(serializedNotification, message, ',');
+    getline(serializedNotification, createdAtTimestampString, ',');
+    util::Timestamp createdAtTimestamp;
+    try
+    {
+        createdAtTimestamp = util::Timestamp::fromString(createdAtTimestampString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid createdAt timestamp");
+    }
     return Factory::getObject<Notification>(
-        serializedNotification.id,
+        id,
-        serializedNotification.recipientUserId,
+        recipientUserId,
-        serializedNotification.title,
+        title,
-        serializedNotification.message,
+        message,
-        serializedNotification.createdAt,
+        createdAtTimestamp
-        serializedNotification.state);
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for notification serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,RecipientID,Title,Message,Timestamp")
+*/
+std::string Notification::getHeaders()
+{
+    return "ID,RecipientID,Title,Message,Timestamp";
 }

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

@@ -9,10 +9,8 @@ Date: 19-May-2026
 #pragma once
 #include <string>
 #include "Timestamp.h"
-#include "Enums.h"
 
 class User;
-struct SerializedNotification;
 
 class Notification
 {
@@ -24,11 +22,10 @@ private:
     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, const util::State& state);
+    Notification(const std::string& id, const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt);
     const std::string& getId() const;
     const std::string& getRecipientUserId() const;
     User* getRecipient() const;
@@ -41,8 +38,7 @@ public:
     void setTitle(const std::string& title);
     void setMessage(const std::string& message);
     void setCreatedAt(const util::Timestamp& createdAt);
-    util::State getState();
+    std::string serialize() const;
-    void setState(util::State state);
+    static Notification* deserialize(const std::string&);
-    SerializedNotification serialize() const;
+    static std::string getHeaders();
-    static Notification* deserialize(const SerializedNotification&);
 };

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

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

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

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

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

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

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

@@ -14,7 +14,6 @@ Date:19-May-2026
 
 class Service;
 class User;
-struct SerializedServiceBooking;
 
 class ServiceBooking
 {
@@ -79,6 +78,7 @@ public:
     void setAssignedTechnicianId(const std::string& assignedTechnicianId);
     void setAssignedTechnician(User* assignedTechnician);
     void setDiscountPercentage(double discountPercentage);
-    SerializedServiceBooking serialize() const;
+    std::string serialize() const;
-    static ServiceBooking* deserialize(const SerializedServiceBooking&);
+    static ServiceBooking* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

@@ -29,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
@@ -52,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)

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

@@ -20,6 +20,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 +34,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 +77,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 +93,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 +114,24 @@ Return type: void
 */
 void UserManagementService::updateUserDetails(const std::string& userID, const std::string& email, const std::string& phone)
 {
-	auto& usersMap = m_dataStore.getUsers();
+	DataStoreLockGuard lock(m_dataStore);
-	int index = usersMap.find(userID);
+	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 +139,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,12 +161,13 @@ Throws:
 */
 util::Vector<Notification*> UserManagementService::getUserNotifications(const std::string& userID)
 {
-	auto& usersMap = m_dataStore.getUsers();
+	DataStoreLockGuard lock(m_dataStore);
-	if (usersMap.find(userID) == -1)
+	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();
@@ -169,97 +187,41 @@ 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();
+	DataStoreLockGuard lock(m_dataStore);
-	if (usersMap.find(userID) == -1)
+	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];
+	User* user = trackedUsersMap.getValueAt(userIndex).data;
 	auto& notifications = user->getNotifications();
 	if (notifications.find(notificationID) == -1)
 	{
 		throw std::runtime_error("No notification found with given NotificationID");
 	}
-	notifications.remove(notificationID);
+	int notificationIndex = trackedNotificationsMap.find(notificationID);
-}
+	if (notificationIndex == -1)
-
+	{
-/*
+		throw std::runtime_error("No notification found with given NotificationID");
-Function: loadUsers
+	}
-Description: Loads users and notifications from persistent storage into the datastore.
+	notifications[notificationID]->setState(util::State::INACTIVE);
-             Validates that each notification’s recipient exists and attaches the
+	trackedNotificationsMap.getValueAt(notificationIndex).state = RecordState::MODIFIED;
-             notification to the corresponding user.
+	m_dataStore.saveNotifications();
-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);
 }
 
 /*
@@ -270,7 +232,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 +245,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,10 +266,12 @@ 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)
@@ -314,21 +282,37 @@ void UserManagementService::removeUser(const std::string& userID)
 			{
 				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();
 		}
 	}
 }
 
+/*
+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/InputHelper.h

@@ -10,6 +10,7 @@
 #include <limits>
 #include <string>
 #include <stdexcept>
+#include <conio.h>
 
 namespace util
 {
@@ -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

@@ -99,4 +99,80 @@ namespace util
         auto observerIDs = service->getObserverIDs();
         util::saveRecords(filePath, observerIDs);
     }
+
+    template<typename TObject>
+    Map<std::string, TObject*> getObjects(const Map<std::string, TrackedRecord<TObject>>& trackedRecords);
+
+    template<typename TObject>
+    Map<std::string, const TObject*> getConstObjects(const Map<std::string, TrackedRecord<TObject>>& trackedRecords);
+
+    template<typename TObject>
+    TrackedRecord<TObject> createNewRecord(TObject* object);
+}
+
+/*
+Function: getObjects
+Description: Extracts the object pointers from a tracked-record
+             collection and returns them as a map keyed by the
+             same identifiers.
+Parameters:
+    - trackedRecords: Collection of tracked records.
+Returns:
+    - Map<std::string, TObject*>: Collection of object pointers.
+*/
+template<typename TObject>
+util::Map<std::string, TObject*> util::getObjects(const util::Map<std::string, TrackedRecord<TObject>>& trackedRecords)
+{
+    util::Map<std::string, TObject*> objects;
+    for (int index = 0; index < trackedRecords.getSize(); ++index)
+    {
+        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/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)

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

@@ -914,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";
@@ -928,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/UserInterface.cpp

@@ -27,8 +27,11 @@ void UserInterface::run()
 {
 	try
 	{
-		m_controller.loadSystemData();
+		if (!m_controller.initialize())
-		m_controller.runSystemChecks();
+		{
+			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!";