Implement Model Refactoring

<UserStory> 1959: Model Refactoring </UserStory>

UserStory #1959

<Changes>
1. Replaced CSV-based User serialization and deserialization with SerializedUser record-based serialization for shared memory storage.
2. Implemented User::serialize() to convert User objects into fixed-size SerializedUser structures containing user details and enum values.
3. Implemented User::deserialize() to reconstruct User objects directly from SerializedUser records.
4. Updated User class interfaces to use SerializedUser types instead of std::string serialization APIs.
5. Removed legacy CSV serialization support, including CSV parsing logic and header generation functionality.
6. Added SerializedUser dependencies through SerializedRecords.h inclusion and forward declaration support.
</Changes>

<Test>
N/A
</Test>

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

.gitignore

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

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

@@ -140,6 +140,7 @@
     <ClCompile Include="models\User.cpp" />
     <ClCompile Include="services\AuthenticationManagementService.cpp" />
     <ClCompile Include="services\InventoryManagementService.cpp" />
+    <ClCompile Include="services\NotificationManagementService.cpp" />
     <ClCompile Include="services\PaymentManagementService.cpp" />
     <ClCompile Include="services\ServiceManagementService.cpp" />
     <ClCompile Include="services\UserManagementService.cpp" />
@@ -156,7 +157,6 @@
     <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" />
@@ -181,6 +181,7 @@
     <ClInclude Include="utilities\Config.h" />
     <ClInclude Include="utilities\Enums.h" />
     <ClInclude Include="utilities\FileHelper.h" />
+    <ClInclude Include="utilities\FileManager.h" />
     <ClInclude Include="utilities\InputHelper.h" />
     <ClInclude Include="utilities\Map.h" />
     <ClInclude Include="utilities\OutputHelper.h" />

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

@@ -114,6 +114,9 @@
     <ClCompile Include="datastores\DataStore.cpp">
       <Filter>Source Files\DataStores</Filter>
     </ClCompile>
+    <ClCompile Include="services\NotificationManagementService.cpp">
+      <Filter>Source Files\Services</Filter>
+    </ClCompile>
     <ClCompile Include="core\patterns\Observer.cpp">
       <Filter>Source Files\Core\Patterns</Filter>
     </ClCompile>
@@ -242,6 +245,9 @@
     <ClInclude Include="utilities\Config.h">
       <Filter>Header Files\Utilities</Filter>
     </ClInclude>
+    <ClInclude Include="utilities\FileManager.h">
+      <Filter>Header Files\Utilities</Filter>
+    </ClInclude>
     <ClInclude Include="utilities\StringHelper.h">
       <Filter>Header Files\Utilities</Filter>
     </ClInclude>
@@ -272,8 +278,5 @@
     <ClInclude Include="datastores\sharedmemory\SharedMemory.h">
       <Filter>Header Files\DataStores\SharedMemory</Filter>
     </ClInclude>
-    <ClInclude Include="datastores\DataStoreLockGuard.h">
-      <Filter>Header Files\DataStores</Filter>
-    </ClInclude>
   </ItemGroup>
 </Project>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -6,6 +6,7 @@ Author: Trenser
 Date: 19-May-2026
 */
 
+
 #pragma once
 #include <string>
 #include "Map.h"
@@ -15,7 +16,6 @@ Date: 19-May-2026
 
 class ServiceBooking;
 class InventoryItem;
-struct SerializedInvoice;
 
 class Invoice
 {
@@ -41,7 +41,7 @@ public:
         ServiceBooking* booking,
         const util::Timestamp& invoiceDate, 
         double laborCost, 
-        const util::Map<std::string, InventoryItem*>& parts,
+        const util::Map<std::string,InventoryItem*>& parts,
         double partsCost,
         double discountPercentage, 
         double totalAmount, 
@@ -87,6 +87,7 @@ public:
     void setPaymentDate(const util::Timestamp& paymentDate);
     void setPaymentMethod(util::PaymentMode paymentMethod);
     void setStatus(util::PaymentStatus status);
-    SerializedInvoice serialize() const;
-    static Invoice* deserialize(const SerializedInvoice&);
+    std::string serialize() const;
+    static Invoice* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

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

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;
-    static JobCard* deserialize(const SerializedJobCard&);
+    std::string serialize() const;
+    static JobCard* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -89,6 +89,23 @@ User::User(const std::string& userId, const std::string& userName, const std::st
     }
 }
 
+/*
+Function: ~User
+Description: Destructor that cleans up dynamically allocated notifications associated with the user.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+User::~User()
+{
+    auto values = m_notifications.getValues();
+    for (int index = 0; index < values.getSize(); index++)
+    {
+        delete values[index];
+    }
+}
+
 /*
 Function: getId
 Description: Retrieves the unique ID of the user.
@@ -155,6 +172,17 @@ const std::string& User::getEmail() const
     return m_email;
 }
 
+/*
+Function: getNotifications
+Description: Retrieves the map of notifications associated with the user.
+Returns:
+    - util::Map<std::string, Notification*>& representing the notifications.
+*/
+util::Map<std::string, Notification*>& User::getNotifications()
+{
+    return m_notifications;
+}
+
 /*
 Function: getUserType
 Description: Retrieves the role of the user.
@@ -255,6 +283,22 @@ void User::setEmail(const std::string& email)
     m_email = email;
 }
 
+/*
+Function: addNotification
+Description: Adds a new notification to the user’s notification map.
+Parameters:
+    - notification: Pointer to the Notification object.
+Returns:
+    - void
+*/
+void User::addNotification(Notification* notification)
+{
+    if (notification)
+    {
+        m_notifications.insert(notification->getId(), notification);
+    }
+}
+
 /*
 Function: setRole
 Description: Sets the role of the user.

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

@@ -26,19 +26,21 @@ private:
     std::string m_name;
     std::string m_phone;
     std::string m_email;
+    util::Map<std::string, Notification*> m_notifications;
     util::UserType m_type;
     util::State m_status;
 public:
     User();
     User(const std::string& userName, const std::string& password, const std::string& name, const std::string& phone, const std::string& email, util::UserType role);
     User(const std::string& userId, const std::string& userName, const std::string& password, const std::string& name, const std::string& phone, const std::string& email, util::UserType role, util::State status);
-    ~User() = default;
+    ~User();
     const std::string& getId() const;
     const std::string& getUserName() const;
     const std::string& getPassword() const;
     const std::string& getName() const;
     const std::string& getPhone() const;
     const std::string& getEmail() const;
+    util::Map<std::string, Notification*>& getNotifications();
     util::UserType getUserType() const;
     util::State getState() const;
     void setId(const std::string& id);
@@ -47,6 +49,7 @@ public:
     void setName(const std::string& name);
     void setPhone(const std::string& phone);
     void setEmail(const std::string& email);
+    void addNotification(Notification* notification) override;
     void setRole(util::UserType role);
     void setState(util::State status);
     SerializedUser serialize() const;

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

@@ -10,8 +10,6 @@ Date:19-May-2026
 #include <stdexcept>
 #include "AuthenticationManagementService.h"
 #include "User.h"
-#include "Utility.h"
-#include "DataStoreLockGuard.h"
 
 User* AuthenticationManagementService::m_authenticatedUser = nullptr;
 
@@ -26,12 +24,11 @@ Return type: bool - true if login successful, false otherwise
 */
 bool AuthenticationManagementService::login(const std::string& username, const std::string& password)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUserMap = m_dataStore.getUsers();
-	int trackedUserMapSize = trackedUserMap.getSize();
-	for (int index = 0; index < trackedUserMapSize; index++)
+	util::Map<std::string, User*> users = m_dataStore.getUsers();
+	int usersMapSize = users.getSize();
+	for (int index = 0; index < usersMapSize; index++)
 	{
-		User* user = trackedUserMap.getValueAt(index).data;
+		User* user = users.getValueAt(index);
 		if (username == user->getUserName())
 		{
 			if (password == user->getPassword())
@@ -77,18 +74,9 @@ Return type: void
 */
 void AuthenticationManagementService::changePassword(const std::string& newPassword)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers();
 	if (m_authenticatedUser == nullptr)
 	{
 		throw std::runtime_error("There is no user currently logged in!");
 	}
-	int index = trackedUsersMap.find(m_authenticatedUser->getId());
-	if (index == -1)
-	{
-		throw std::runtime_error("User does not exist!\n");
-	}
 	m_authenticatedUser->setPassword(newPassword);
-	trackedUsersMap.getValueAt(index).state = RecordState::MODIFIED;
-	m_dataStore.saveUsers();
 }

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

@@ -12,13 +12,14 @@ Date: 22-May-2026
 #include "Config.h"
 #include "Enums.h"
 #include "Factory.h"
+#include "FileManager.h"
 #include "InventoryItem.h"
 #include "InventoryManagementService.h"
 #include "Timestamp.h"
 #include "User.h"
 #include "Utility.h"
 #include "Vector.h"
-#include "DataStoreLockGuard.h"
+
 
 util::Map<std::string, User*> InventoryManagementService::m_observers{};
 
@@ -57,19 +58,18 @@ Returns:
 */
 void InventoryManagementService::sendLowStockAlerts()
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInventoryItemsMap = m_dataStore.getInventoryItems();
-	auto& trackedUserMap = m_dataStore.getUsers();
-	if (trackedInventoryItemsMap.isEmpty())
+	auto& inventoryItems = m_dataStore.getInventoryItems();
+	if (inventoryItems.isEmpty())
 	{
 		return;
 	}
-	int inventoryItemsSize = trackedInventoryItemsMap.getSize();
-	int usersMapSize = trackedUserMap.getSize();
+	int inventoryItemsSize = inventoryItems.getSize();
+	auto& usersMap = m_dataStore.getUsers();
+	int usersMapSize = usersMap.getSize();
 	util::Vector<User*> adminUsers;
 	for (int index = 0; index < usersMapSize; index++)
 	{
-		User* user = trackedUserMap.getValueAt(index).data;
+		User* user = usersMap.getValueAt(index);
 		if (user->getUserType() == util::UserType::ADMIN)
 		{
 			adminUsers.push_back(user);
@@ -82,7 +82,7 @@ void InventoryManagementService::sendLowStockAlerts()
 	}
 	for (int index = 0; index < inventoryItemsSize; index++)
 	{
-		InventoryItem* inventoryItem = trackedInventoryItemsMap.getValueAt(index).data;
+		InventoryItem* inventoryItem = inventoryItems.getValueAt(index);
 		if (inventoryItem && inventoryItem->getQuantity() < config::threshold::INVENTORY_LOW_STOCK_THRESHOLD)
 		{
 			sendLowStockAlertsToAdmins(*this, inventoryItem, adminUsers);
@@ -90,6 +90,95 @@ void InventoryManagementService::sendLowStockAlerts()
 	}
 }
 
+/*
+Function: getObserverIDs
+Description: Retrieves the IDs of all observers currently attached to the
+			 InventoryManagementService.
+Parameters:
+	- None
+Returns:
+	- util::Vector<std::string>: Vector of observer user IDs
+*/
+util::Vector<std::string> InventoryManagementService::getObserverIDs()
+{
+	util::Vector<std::string> observerIDs;
+	int numberOfObservers = m_observers.getSize();
+	for (int index = 0; index < numberOfObservers; index++)
+	{
+		User* observer = m_observers.getValueAt(index);
+		if (observer)
+		{
+			observerIDs.push_back(observer->getId());
+		}
+	}
+	return observerIDs;
+}
+
+/*
+Function: loadInventoryItems
+Description: Loads inventory items from persistent storage into the datastore.
+			 Uses FileManager to deserialize inventory items from the configured file.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void InventoryManagementService::loadInventoryItems()
+{
+	util::FileManager<InventoryItem> inventoryItemFileManager(config::file::INVENTORYITEM_FILE);
+	auto& inventoryItems = m_dataStore.getInventoryItems();
+	auto inventoryItemsMap = inventoryItemFileManager.load();
+	int numberOfInventoryItems = inventoryItemsMap.getSize();
+	for (int index = 0; index < numberOfInventoryItems; index++)
+	{
+		inventoryItems[inventoryItemsMap.getKeyAt(index)] = inventoryItemsMap.getValueAt(index);
+	}
+}
+
+/*
+Function: saveInventoryItems
+Description: Saves inventory items from the datastore to persistent storage.
+			 Uses FileManager to serialize inventory items into the configured file.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void InventoryManagementService::saveInventoryItems()
+{
+	util::FileManager<InventoryItem> inventoryItemFileManager(config::file::INVENTORYITEM_FILE);
+	auto& inventoryItems = m_dataStore.getInventoryItems();
+	inventoryItemFileManager.save(inventoryItems);
+}
+
+/*
+Function: loadObservers
+Description: Loads observer IDs from persistent storage and attaches corresponding
+			 users as observers to the InventoryManagementService.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void InventoryManagementService::loadObservers()
+{
+	util::loadObservers(config::file::INVENTORYMANAGEMENTOBSERVERS, this, m_dataStore);
+}
+
+/*
+Function: saveObservers
+Description: Saves the current observer IDs of the InventoryManagementService
+			 to persistent storage for future retrieval.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void InventoryManagementService::saveObservers()
+{
+	util::saveObservers(config::file::INVENTORYMANAGEMENTOBSERVERS, this);
+}
+
 /*
 Function: addInventoryItem
 Description: Creates a new inventory item using the Factory and inserts it
@@ -101,11 +190,8 @@ Return type: void
 */
 void InventoryManagementService::addInventoryItem(const std::string& partName, int quantity, double price)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
     InventoryItem* newItem = Factory::getObject<InventoryItem>(partName, quantity, price);
-	trackedInventoryItemMap.insert(newItem->getId(), util::createNewRecord(newItem));
-	m_dataStore.saveInventoryItems();
+    m_dataStore.getInventoryItems().insert(newItem->getId(), newItem);
 }
 
 /*
@@ -117,22 +203,16 @@ Return type: void
 */
 void InventoryManagementService::addInventoryItemStock(const std::string& selectedItemId, int quantity)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
-	int index = trackedInventoryItemMap.find(selectedItemId);
-	if (index == -1)
-	{
-		throw std::runtime_error("Inventory update failed: Item ID '" + selectedItemId + "' not found.");
-	}
-	InventoryItem* item = trackedInventoryItemMap.getValueAt(index).data;
-	if (item == nullptr)
-	{
-		throw std::runtime_error("Inventory update failed. Item does not exist.\n");
-	}
-	int totalQuantity = item->getQuantity() + quantity;
-	item->setQuantity(totalQuantity);
-	trackedInventoryItemMap.getValueAt(index).state = RecordState::MODIFIED;
-	m_dataStore.saveInventoryItems();
+    int index = m_dataStore.getInventoryItems().find(selectedItemId);
+    if (index != -1)
+    {
+        InventoryItem* item = m_dataStore.getInventoryItems().getValueAt(index);
+        if (item != nullptr)
+        {
+            int totalQuantity = item->getQuantity() + quantity;
+            item->setQuantity(totalQuantity);
+        }
+    }
 }
 
 /*
@@ -143,10 +223,7 @@ Return type: util::Map<std::string, InventoryItem*>
 */
 util::Map<std::string, InventoryItem*> InventoryManagementService::getInventoryItems()
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
-	auto inventoryMap = util::getObjects(trackedInventoryItemMap);
-	return inventoryMap;
+	return m_dataStore.getInventoryItems();
 }
 
 /*
@@ -157,21 +234,15 @@ Return type: void
 */
 void InventoryManagementService::removeInventoryItem(const std::string& inventoryItemID)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
-	int index = trackedInventoryItemMap.find(inventoryItemID);
-	if (index == -1)
-	{
-		throw std::runtime_error("Inventory removal failed: Item ID '" + inventoryItemID + "' not found.");
-	}
-	InventoryItem* item = trackedInventoryItemMap.getValueAt(index).data;
-	if (item == nullptr)
-	{
-		throw std::runtime_error("Inventory removal failed: Item ID does not exist.");
-	}
-	item->setState(util::State::INACTIVE);
-	trackedInventoryItemMap.getValueAt(index).state = RecordState::MODIFIED;
-	m_dataStore.saveInventoryItems();
+    int index = m_dataStore.getInventoryItems().find(inventoryItemID);
+    if (index != -1)
+    {
+        InventoryItem* item = m_dataStore.getInventoryItems().getValueAt(index);
+        if (item != nullptr)
+        {
+            item->setState(util::State::INACTIVE);
+        }
+    }
 }
 
 /*
@@ -182,19 +253,12 @@ Return type: InventoryItem*
 */
 InventoryItem* InventoryManagementService::getInventoryItem(const std::string& inventoryItemID)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
-    int index = trackedInventoryItemMap.find(inventoryItemID);
-    if (index == -1)
+    int index = m_dataStore.getInventoryItems().find(inventoryItemID);
+    if (index != -1)
     {
-		return nullptr;
+        return m_dataStore.getInventoryItems().getValueAt(index);
     }
-	InventoryItem* inventoryItem = trackedInventoryItemMap.getValueAt(index).data;
-	if (inventoryItem == nullptr)
-	{
-		throw std::runtime_error("Item ID does not exist.");
-	}
-	return inventoryItem;
+    return nullptr;
 }
 
 /*
@@ -207,9 +271,6 @@ Returns:
 */
 void InventoryManagementService::attach(User* user)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	m_observers.clear();
-	m_observers = m_dataStore.getInventoryManagementObservers();
 	if (user)
 	{
 		const std::string& userID = user->getId();
@@ -218,7 +279,6 @@ void InventoryManagementService::attach(User* user)
 			m_observers[userID] = user;
 		}
 	}
-	m_dataStore.saveInventoryManagementObservers(m_observers);
 }
 
 /*
@@ -231,9 +291,6 @@ Returns:
 */
 void InventoryManagementService::detach(User* user)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	m_observers.clear();
-	m_observers = m_dataStore.getInventoryManagementObservers();
 	if (user)
 	{
 		const std::string& userID = user->getId();
@@ -242,7 +299,6 @@ void InventoryManagementService::detach(User* user)
 			m_observers.remove(userID);
 		}
 	}
-	m_dataStore.saveInventoryManagementObservers(m_observers);
 }
 
 /*
@@ -259,27 +315,27 @@ Throws:
 */
 void InventoryManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
 {
-	if (!user)
+	if (user)
 	{
-		return;
+		if (m_observers.find(user->getId()) != -1)
+		{
+			Notification* notification =
+				Factory::getObject<Notification>(
+					user->getId(),
+					user,
+					title,
+					message,
+					util::Timestamp()
+				);
+			if (notification)
+			{
+				user->addNotification(notification);
+			}
+			else
+			{
+				throw std::runtime_error("Failed to create notification");
+			}
+		}
 	}
-	DataStoreLockGuard lock(m_dataStore);
-	m_observers = m_dataStore.getInventoryManagementObservers();
-	if (m_observers.find(user->getId()) == -1)
-	{
-		return;
-	}
-	Notification* notification = Factory::getObject<Notification>(
-		user->getId(),
-		title,
-		message,
-		util::Timestamp());
-	if (!notification)
-	{
-		throw std::runtime_error("Failed to create notification");
-	}
-	auto& trackedNotificationsMap = m_dataStore.getNotifications();
-	trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
-	m_dataStore.saveNotifications();
 }
 

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

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

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

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

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

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

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

@@ -11,17 +11,16 @@ Date: 20-May-2026
 #include "Config.h"
 #include "Enums.h"
 #include "Factory.h"
+#include "FileManager.h"
 #include "InventoryItem.h"
 #include "Invoice.h"
 #include "JobCard.h"
 #include "PaymentManagementService.h"
-#include "DataStoreLockGuard.h"
 #include "Service.h"
 #include "ServiceBooking.h"
 #include "Timestamp.h"
 #include "User.h"
 #include "Utility.h"
-#include "DataStoreLockGuard.h"
 
 util::Map<std::string, User*> PaymentManagementService::m_observers{};
 
@@ -35,9 +34,6 @@ Returns:
 */
 void PaymentManagementService::attach(User* user)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	m_observers.clear();
-	m_observers = m_dataStore.getPaymentManagementObservers();
 	if (user)
 	{
 		const std::string& userID = user->getId();
@@ -46,7 +42,6 @@ void PaymentManagementService::attach(User* user)
 			m_observers[userID] = user;
 		}
 	}
-	m_dataStore.savePaymentManagementObservers(m_observers);
 }
 
 /*
@@ -59,9 +54,6 @@ Returns:
 */
 void PaymentManagementService::detach(User* user)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	m_observers.clear();
-	m_observers = m_dataStore.getPaymentManagementObservers();
 	if (user)
 	{
 		const std::string& userID = user->getId();
@@ -70,7 +62,6 @@ void PaymentManagementService::detach(User* user)
 			m_observers.remove(userID);
 		}
 	}
-	m_dataStore.savePaymentManagementObservers(m_observers);
 }
 
 /*
@@ -87,28 +78,28 @@ Throws:
 */
 void PaymentManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
 {
-	if (!user)
+	if (user)
 	{
-		return;
+		if (m_observers.find(user->getId()) != -1)
+		{
+			Notification* notification =
+				Factory::getObject<Notification>(
+					user->getId(),
+					user,
+					title,
+					message,
+					util::Timestamp()
+				);
+			if (notification)
+			{
+				user->addNotification(notification);
+			}
+			else
+			{
+				throw std::runtime_error("Failed to create notification");
+			}
+		}
 	}
-	DataStoreLockGuard lock(m_dataStore);
-	m_observers = m_dataStore.getPaymentManagementObservers();
-	if (m_observers.find(user->getId()) == -1)
-	{
-		return;
-	}
-	Notification* notification = Factory::getObject<Notification>(
-		user->getId(),
-		title,
-		message,
-		util::Timestamp());
-	if (!notification)
-	{
-		throw std::runtime_error("Failed to create notification");
-	}
-	auto& trackedNotificationsMap = m_dataStore.getNotifications();
-	trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
-	m_dataStore.saveNotifications();
 }
 
 /*
@@ -122,12 +113,11 @@ Returns:
 */
 void PaymentManagementService::sendPaymentReminders()
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInvoicesMap = m_dataStore.getInvoices();
-	int invoicesMapSize = trackedInvoicesMap.getSize();
+	auto& invoicesMap = m_dataStore.getInvoices();
+	int invoicesMapSize = invoicesMap.getSize();
 	for (int index = 0; index < invoicesMapSize; index++)
 	{
-		const Invoice* invoice = trackedInvoicesMap.getValueAt(index).data;
+		const Invoice* invoice = invoicesMap.getValueAt(index);
 		if (invoice && invoice->getStatus() == util::PaymentStatus::PENDING)
 		{
 			util::Timestamp invoiceCreationTimestamp = invoice->getInvoiceDate();
@@ -150,6 +140,123 @@ void PaymentManagementService::sendPaymentReminders()
 	}
 }
 
+/*
+Function: getObserverIDs
+Description: Retrieves the IDs of all observers currently attached to the
+             PaymentManagementService.
+Parameters:
+    - None
+Returns:
+    - util::Vector<std::string>: Vector of observer user IDs
+*/
+util::Vector<std::string> PaymentManagementService::getObserverIDs()
+{
+	util::Vector<std::string> observerIDs;
+	int numberOfObservers = m_observers.getSize();
+	for (int index = 0; index < numberOfObservers; index++)
+	{
+		User* observer = m_observers.getValueAt(index);
+		if (observer)
+		{
+			observerIDs.push_back(observer->getId());
+		}
+	}
+	return observerIDs;
+}
+
+/*
+Function: loadInvoices
+Description: Loads invoices from persistent storage into the datastore.
+             Validates associated service bookings and inventory parts before
+             attaching them to each invoice. Throws exceptions if invalid IDs
+             are encountered.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a booking ID or part ID is invalid
+*/
+void PaymentManagementService::loadInvoices()
+{
+    util::FileManager<Invoice> invoiceFileManager(config::file::INVOICE_FILE);
+    auto& invoices = m_dataStore.getInvoices();
+    auto& serviceBookings = m_dataStore.getServiceBookings();
+    auto& inventoryItems = m_dataStore.getInventoryItems();
+    auto invoicesMap = invoiceFileManager.load();
+    for (int invoiceIndex = 0; invoiceIndex < invoicesMap.getSize(); invoiceIndex++)
+    {
+        Invoice* invoice = invoicesMap.getValueAt(invoiceIndex);
+        int bookingIndex = serviceBookings.find(invoice->getBookingId());
+        if (bookingIndex == -1)
+        {
+            throw std::runtime_error("Invalid Booking ID");
+        }
+        ServiceBooking* booking = serviceBookings.getValueAt(bookingIndex);
+        invoice->setBooking(booking);
+        util::Map<std::string, InventoryItem*> invoiceParts;
+        auto& partIDs = invoice->getPartIDs();
+        for (int partIndex = 0; partIndex < partIDs.getSize(); partIndex++)
+        {
+            const std::string& partID = partIDs[partIndex];
+            int inventoryIndex = inventoryItems.find(partID);
+            if (inventoryIndex == -1)
+            {
+                throw std::runtime_error("Invalid Part ID");
+            }
+            invoiceParts[partID] = inventoryItems.getValueAt(inventoryIndex);
+        }
+        invoice->setParts(invoiceParts);
+        invoices[invoice->getId()] = invoice;
+    }
+}
+
+/*
+Function: saveInvoices
+Description: Saves invoices from the datastore to persistent storage.
+             Uses FileManager to serialize invoices into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void PaymentManagementService::saveInvoices()
+{
+    util::FileManager<Invoice> invoiceFileManager(config::file::INVOICE_FILE);
+    auto& invoices = m_dataStore.getInvoices();
+    invoiceFileManager.save(invoices);
+}
+
+/*
+Function: loadObservers
+Description: Loads observer IDs from persistent storage and attaches corresponding
+             users as observers to the PaymentManagementService.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if an observer ID is invalid (not found in datastore)
+*/
+void PaymentManagementService::loadObservers()
+{
+    util::loadObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this, m_dataStore);
+}
+
+/*
+Function: saveObservers
+Description: Saves the current observer IDs of the PaymentManagementService
+             to persistent storage for future retrieval.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void PaymentManagementService::saveObservers()
+{
+    util::saveObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this);
+}
+
 /*
 Function: createInventoryItemsMap (static helper)
 Description: Builds a map of inventory items required for a given service and adds them to the booking’s inventory map.
@@ -183,7 +290,6 @@ Throws:
 */
 void PaymentManagementService::generateInvoice(ServiceBooking* booking)
 {
-	DataStoreLockGuard lock(m_dataStore);
 	if (!booking)
 	{
 		throw std::runtime_error("Invoice generation failed: booking is null.");
@@ -193,10 +299,10 @@ void PaymentManagementService::generateInvoice(ServiceBooking* booking)
 	std::string bookingID = booking->getId();
 	util::Map<std::string, Service*> servicesInTheBookedService = booking->getServices();
 	util::Map<std::string, InventoryItem*> completeInventoryItemMapOfBooking;
-	auto& currentTrackedJobCards = m_dataStore.getJobCards();
-	for (int iterator = 0; iterator < currentTrackedJobCards.getSize(); iterator++)
+	util::Map<std::string, JobCard*> currentJobCards = m_dataStore.getJobCards();
+	for (int iterator = 0; iterator < currentJobCards.getSize(); iterator++)
 	{
-		JobCard* currentJobCard = currentTrackedJobCards.getValueAt(iterator).data;
+		JobCard* currentJobCard = currentJobCards.getValueAt(iterator);
 		util::ServiceJobStatus currentJobCardStatus = currentJobCard->getStatus();
 		if (currentJobCard->getBookingId() == bookingID && currentJobCardStatus != util::ServiceJobStatus::CANCELLED && currentJobCardStatus != util::ServiceJobStatus::COMPLETED)
 		{
@@ -216,9 +322,8 @@ void PaymentManagementService::generateInvoice(ServiceBooking* booking)
 	totalServiceCost = totalLaborCost + totalPartsCost;
 	totalServiceCost -= (totalServiceCost * (discountPercentage / 100));
 	Invoice* invoice = Factory::getObject<Invoice>(bookingID, booking, util::Timestamp(), totalLaborCost, completeInventoryItemMapOfBooking, totalPartsCost, discountPercentage, totalServiceCost, util::Timestamp(), util::PaymentMode::NOTSET, util::PaymentStatus::PENDING);
-	auto& currentTrackedInvoices = m_dataStore.getInvoices();
-	currentTrackedInvoices.insert(invoice->getId(), util::createNewRecord(invoice));
-	m_dataStore.saveInvoices();
+	util::Map<std::string, Invoice*>& currentInvoices = m_dataStore.getInvoices();
+	currentInvoices.insert(invoice->getId(), invoice);
 }
 
 /*
@@ -231,12 +336,11 @@ Returns:
 */
 util::Map<std::string, Invoice*> PaymentManagementService::getInvoices(const std::string& customerID)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& currentTrackedInvoices = m_dataStore.getInvoices();
+	util::Map<std::string, Invoice*>& currentInvoices = m_dataStore.getInvoices();
 	util::Map<std::string, Invoice*> currentUserInvoices;
-	for (int iterator = 0; iterator < currentTrackedInvoices.getSize(); iterator++)
+	for (int iterator = 0; iterator < currentInvoices.getSize(); iterator++)
 	{
-		Invoice* currentInvoice = currentTrackedInvoices.getValueAt(iterator).data;
+		Invoice* currentInvoice = currentInvoices.getValueAt(iterator);
 		if (currentInvoice->getBooking()->getCustomerId() == customerID)
 		{
 			currentUserInvoices.insert(currentInvoice->getId(), currentInvoice);
@@ -259,13 +363,11 @@ Throws:
 */
 void PaymentManagementService::completePayment(const std::string& invoiceID, util::PaymentMode paymentMode)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& currentTrackedInvoices = m_dataStore.getInvoices();
-	int invoiceIndex = currentTrackedInvoices.find(invoiceID);
+	auto& currentInvoices = m_dataStore.getInvoices();
+	int invoiceIndex = currentInvoices.find(invoiceID);
 	if (invoiceIndex != -1)
 	{
-		auto& trackedInvoice = currentTrackedInvoices.getValueAt(invoiceIndex);
-		Invoice* invoice = trackedInvoice.data;
+		Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
 		if (invoice && invoice->getStatus() != util::PaymentStatus::PAID)
 		{
 			User* currentUser = invoice->getBooking()->getCustomer();
@@ -276,14 +378,12 @@ void PaymentManagementService::completePayment(const std::string& invoiceID, uti
 			title = "Payment successful";
 			message = "Payment successful for Invoice ID " + invoiceID;
 			sendNotification(currentUser, title, message);
-			trackedInvoice.state = RecordState::MODIFIED;
 		}
 	}
 	else
 	{
 		throw std::runtime_error("Payment failed: invalid invoice ID.");
 	}
-	m_dataStore.saveInvoices();
 }
 
 /*
@@ -292,14 +392,11 @@ Description: Provides access to all invoices stored in the data store.
 Parameters:
 	- none
 Returns:
-	- util::Map<std::string, Invoice*>: Map of invoice IDs to invoice objects
+	- util::Map<std::string, Invoice*>&: Map of invoice IDs to invoice objects
 */
-util::Map<std::string, Invoice*> PaymentManagementService::getAllInvoices()
+util::Map<std::string, Invoice*>& PaymentManagementService::getAllInvoices()
 {
-	DataStoreLockGuard lock(m_dataStore);
-	util::Map<std::string, Invoice*> invoices;
-	invoices = util::getObjects(m_dataStore.getInvoices());
-	return invoices;
+	return m_dataStore.getInvoices();
 }
 
 /*
@@ -315,24 +412,20 @@ Throws:
 */
 void PaymentManagementService::confirmPayment(const std::string& invoiceID)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& currentTrackedInvoices = m_dataStore.getInvoices();
-	int invoiceIndex = currentTrackedInvoices.find(invoiceID);
+	auto& currentInvoices = m_dataStore.getInvoices();
+	int invoiceIndex = currentInvoices.find(invoiceID);
 	if (invoiceIndex == -1)
 	{
 		throw std::runtime_error("Payment confirmation failed: invalid invoice ID.");
 	}
-	auto& trackedInvoice = currentTrackedInvoices.getValueAt(invoiceIndex);
-	Invoice* invoice = trackedInvoice.data;
+	Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
 	if (!invoice || invoice->getStatus() != util::PaymentStatus::PAID)
 	{
 		throw std::runtime_error("Payment confirmation failed: invoice is not awaiting confirmation.");
 	}
 	User* currentUser = invoice->getBooking()->getCustomer();
 	invoice->setStatus(util::PaymentStatus::COMPLETED);
-	trackedInvoice.state = RecordState::MODIFIED;
 	std::string title = "Payment Confirmed";
 	std::string message = "Payment Confirmed for Invoice ID " + invoiceID;
 	sendNotification(currentUser, title, message);
-	m_dataStore.saveInvoices();
 }

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

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

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/ServiceManagementService.cpp

@@ -14,6 +14,7 @@ Date:19-May-2026
 #include "DataStore.h"
 #include "Enums.h"
 #include "Factory.h"
+#include "FileManager.h"
 #include "InventoryItem.h"
 #include "JobCard.h"
 #include "NotificationManagementService.h"
@@ -24,9 +25,7 @@ Date:19-May-2026
 #include "Timestamp.h"
 #include "User.h"
 #include "UserManagementService.h"
-#include "DataStoreLockGuard.h"
 #include "Utility.h"
-#include "DataStoreLockGuard.h"
 
 /*
 Function: purchaseService
@@ -47,19 +46,18 @@ void ServiceManagementService::purchaseService(const util::Vector<std::string>&
 	{
 		throw std::runtime_error("No user is currently logged in!");
 	}
-    DataStoreLockGuard lock(m_dataStore);
-	auto& trackedServicesMap = m_dataStore.getServices();
-	auto& trackedServiceBookingMap = m_dataStore.getServiceBookings();
+	auto& servicesMap = m_dataStore.getServices();
+	auto& serviceBookingMap = m_dataStore.getServiceBookings();
 	util::Map<std::string, Service*> selectedServices;
 	int selectedServicesCount = serviceIDs.getSize();
 	for (int index = 0; index < selectedServicesCount; index++)
 	{
-		int serviceIndex = trackedServicesMap.find(serviceIDs[index]);
+		int serviceIndex = servicesMap.find(serviceIDs[index]);
 		if (serviceIndex == -1)
 		{
 			throw std::runtime_error("Service not found!");
 		}
-		Service* service = trackedServicesMap.getValueAt(serviceIndex).data;
+		Service* service = servicesMap.getValueAt(serviceIndex);
 		selectedServices[service->getId()] = service;
 	}
 	ServiceBooking* serviceBooking = Factory::getObject<ServiceBooking>(util::ServiceJobStatus::PENDING, selectedServices, authenticatedUser->getId(), authenticatedUser, vehicleNumber, vehicleBrand, vehicleModel, 0);
@@ -67,7 +65,7 @@ void ServiceManagementService::purchaseService(const util::Vector<std::string>&
 	{
 		throw std::runtime_error("Failed to create service booking");
 	}
-	trackedServiceBookingMap[serviceBooking->getId()] =  util::createNewRecord(serviceBooking);
+	serviceBookingMap[serviceBooking->getId()] = serviceBooking;
     std::string title = "Service Booking succeeded";
     std::string message = "Your service booking has been successfully placed with ID " + serviceBooking->getId();
     sendNotification(authenticatedUser, title, message);
@@ -92,22 +90,21 @@ void ServiceManagementService::purchaseComboPackage(const std::string& comboPack
 	{
 		throw std::runtime_error("No user is currently logged in!");
 	}
-    DataStoreLockGuard lock(m_dataStore);
-	auto& trackedComboPackagesMap = m_dataStore.getComboPackages();
-	auto& trackedServiceBookingMap = m_dataStore.getServiceBookings();
-	int comboPackageIndex = trackedComboPackagesMap.find(comboPackageID);
+	auto& comboPackagesMap = m_dataStore.getComboPackages();
+	auto& serviceBookingMap = m_dataStore.getServiceBookings();
+	int comboPackageIndex = comboPackagesMap.find(comboPackageID);
 	if (comboPackageIndex == -1)
 	{
 		throw std::runtime_error("Combo Package not found!");
 	}
-	const ComboPackage* comboPackage = trackedComboPackagesMap[comboPackageID].data;
+	const ComboPackage* comboPackage = comboPackagesMap[comboPackageID];
 	util::Map<std::string, Service*> selectedServices = comboPackage->getServices();
 	ServiceBooking* serviceBooking = Factory::getObject<ServiceBooking>(util::ServiceJobStatus::PENDING, selectedServices, authenticatedUser->getId(), authenticatedUser, vehicleNumber, vehicleBrand, vehicleModel, comboPackage->getDiscountPercentage());
 	if (serviceBooking == nullptr)
 	{
 		throw std::runtime_error("Failed to create combo package service booking");
 	}
-	trackedServiceBookingMap[serviceBooking->getId()] = util::createNewRecord(serviceBooking);
+	serviceBookingMap[serviceBooking->getId()] = serviceBooking;
     std::string title = "Combo Package Service Booking succeeded";
     std::string message = "Your service booking for the combo package has been successfully placed with ID " + serviceBooking->getId();
     sendNotification(authenticatedUser, title, message);
@@ -125,9 +122,6 @@ Returns:
 */
 void ServiceManagementService::attach(User* user)
 {
-    DataStoreLockGuard lock(m_dataStore);
-    m_observers.clear();
-    m_observers = m_dataStore.getServiceManagementObservers();
 	if (user)
 	{
 		const std::string& userID = user->getId();
@@ -136,7 +130,6 @@ void ServiceManagementService::attach(User* user)
 			m_observers[userID] = user;
 		}
 	}
-    m_dataStore.saveServiceManagementObservers(m_observers);
 }
 
 /*
@@ -149,9 +142,6 @@ Returns:
 */
 void ServiceManagementService::detach(User* user)
 {
-    DataStoreLockGuard lock(m_dataStore);
-    m_observers.clear();
-    m_observers = m_dataStore.getServiceManagementObservers();
 	if (user)
 	{
 		const std::string& userID = user->getId();
@@ -160,7 +150,6 @@ void ServiceManagementService::detach(User* user)
 			m_observers.remove(userID);
 		}
 	}
-    m_dataStore.saveServiceManagementObservers(m_observers);
 }
 
 /*
@@ -177,28 +166,345 @@ Throws:
 */
 void ServiceManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
 {
-    if (!user)
+	if (user)
+	{
+		if (m_observers.find(user->getId()) != -1)
+		{
+			Notification* notification =
+				Factory::getObject<Notification>(
+					user->getId(),
+					user,
+					title,
+					message,
+					util::Timestamp()
+				);
+			if (notification)
+			{
+				user->addNotification(notification);
+			}
+			else
+			{
+				throw std::runtime_error("Failed to create notification");
+			}
+		}
+	}
+}
+
+/*
+Function: getObserverIDs
+Description: Retrieves the IDs of all observers currently attached to the
+             ServiceManagementService.
+Parameters:
+    - None
+Returns:
+    - util::Vector<std::string>: Vector of observer user IDs
+*/
+util::Vector<std::string> ServiceManagementService::getObserverIDs()
+{
+	util::Vector<std::string> observerIDs;
+	int numberOfObservers = m_observers.getSize();
+	for (int index = 0; index < numberOfObservers; index++)
+	{
+		User* observer = m_observers.getValueAt(index);
+		if (observer)
+		{
+			observerIDs.push_back(observer->getId());
+		}
+	}
+	return observerIDs;
+}
+
+/*
+Function: loadServices
+Description: Loads services from persistent storage into the datastore.
+             Validates required inventory items and attaches them to each service.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if an inventory item ID is invalid
+*/
+void ServiceManagementService::loadServices()
+{
+    util::FileManager<Service> serviceFileManager(config::file::SERVICE_FILE);
+    auto& services = m_dataStore.getServices();
+    auto& inventoryItems = m_dataStore.getInventoryItems();
+    auto servicesMap = serviceFileManager.load();
+    for (int serviceIndex = 0; serviceIndex < servicesMap.getSize(); serviceIndex++)
     {
-        return;
+        Service* service = servicesMap.getValueAt(serviceIndex);
+        services[service->getId()] = service;
+        util::Map<std::string, InventoryItem*> inventoryItemsMap;
+        auto& inventoryItemIDs = service->getRequiredInventoryItemIDs();
+        for (int inventoryItemIndex = 0; inventoryItemIndex < inventoryItemIDs.getSize(); inventoryItemIndex++)
+        {
+            const std::string& inventoryItemID = inventoryItemIDs[inventoryItemIndex];
+            int index = inventoryItems.find(inventoryItemID);
+            if (index == -1)
+            {
+                throw std::runtime_error("Invalid Inventory Item ID");
+            }
+            inventoryItemsMap[inventoryItemID] = inventoryItems.getValueAt(index);
+        }
+        service->setRequiredInventoryItems(inventoryItemsMap);
     }
-    DataStoreLockGuard lock(m_dataStore);
-    m_observers = m_dataStore.getServiceManagementObservers();
-    if (m_observers.find(user->getId()) == -1)
+}
+
+/*
+Function: saveServices
+Description: Saves services from the datastore to persistent storage.
+             Uses FileManager to serialize services into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void ServiceManagementService::saveServices()
+{
+	util::FileManager<Service> serviceFileManager(config::file::SERVICE_FILE);
+	auto& services = m_dataStore.getServices();
+	serviceFileManager.save(services);
+}
+
+/*
+Function: loadComboPackages
+Description: Loads combo packages from persistent storage into the datastore.
+             Validates associated services and attaches them to each package.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a service ID is invalid
+*/
+void ServiceManagementService::loadComboPackages()
+{
+    util::FileManager<ComboPackage> comboPackageFileManager(config::file::COMBOPACKAGE_FILE);
+    auto& comboPackages = m_dataStore.getComboPackages();
+    auto& services = m_dataStore.getServices();
+    auto comboPackagesMap = comboPackageFileManager.load();
+    for (int packageIndex = 0; packageIndex < comboPackagesMap.getSize(); packageIndex++)
     {
-        return;
+        ComboPackage* comboPackage = comboPackagesMap.getValueAt(packageIndex);
+        util::Map<std::string, Service*> packageServices;
+        auto& serviceIDs = comboPackage->getServiceIDs();
+        for (int serviceIndex = 0; serviceIndex < serviceIDs.getSize(); serviceIndex++)
+        {
+            const std::string& serviceID = serviceIDs[serviceIndex];
+            int serviceMapIndex = services.find(serviceID);
+            if (serviceMapIndex == -1)
+            {
+                throw std::runtime_error("Invalid Service ID");
+            }
+            packageServices[serviceID] = services.getValueAt(serviceMapIndex);
+        }
+        comboPackage->setServices(packageServices);
+        comboPackages[comboPackage->getId()] = comboPackage;
     }
-    Notification* notification = Factory::getObject<Notification>(
-        user->getId(),
-        title,
-        message,
-        util::Timestamp());
-    if (!notification)
+}
+
+/*
+Function: saveComboPackages
+Description: Saves combo packages from the datastore to persistent storage.
+             Uses FileManager to serialize combo packages into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void ServiceManagementService::saveComboPackages()
+{
+    util::FileManager<ComboPackage> comboPackageFileManager(config::file::COMBOPACKAGE_FILE);
+    auto& comboPackages = m_dataStore.getComboPackages();
+    comboPackageFileManager.save(comboPackages);
+}
+
+/*
+Function: loadServiceBookings
+Description: Loads service bookings from persistent storage into the datastore.
+             Validates associated services, customers, and technicians before
+             attaching them to each booking.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a service ID, customer ID, or technician ID is invalid
+    - std::runtime_error if a user is not of the expected type (customer/technician)
+*/
+void ServiceManagementService::loadServiceBookings()
+{
+    util::FileManager<ServiceBooking> bookingFileManager(config::file::SERVICEBOOKING_FILE);
+    auto& serviceBookings = m_dataStore.getServiceBookings();
+    auto& services = m_dataStore.getServices();
+    auto& users = m_dataStore.getUsers();
+    auto bookingsMap = bookingFileManager.load();
+    for (int bookingIndex = 0; bookingIndex < bookingsMap.getSize(); bookingIndex++)
     {
-        throw std::runtime_error("Failed to create notification");
+        ServiceBooking* booking = bookingsMap.getValueAt(bookingIndex);
+        util::Map<std::string, Service*> bookingServices;
+        auto& serviceIDs = booking->getServiceIDs();
+        for (int serviceIndex = 0; serviceIndex < serviceIDs.getSize(); serviceIndex++)
+        {
+            const std::string& serviceID = serviceIDs[serviceIndex];
+            int serviceMapIndex = services.find(serviceID);
+            if (serviceMapIndex == -1)
+            {
+                throw std::runtime_error("Invalid Service ID");
+            }
+
+            bookingServices[serviceID] = services.getValueAt(serviceMapIndex);
+        }
+        booking->setServices(bookingServices);
+        int customerIndex = users.find(booking->getCustomerId());
+        if (customerIndex == -1)
+        {
+            throw std::runtime_error("Invalid Customer ID");
+        }
+        User* customer = users.getValueAt(customerIndex);
+        if (customer->getUserType() != util::UserType::CUSTOMER)
+        {
+            throw std::runtime_error("User is not a customer");
+        }
+        booking->setCustomer(customer);
+        const std::string& technicianId = booking->getAssignedTechnicianId();
+        if (!technicianId.empty())
+        {
+            int technicianIndex = users.find(technicianId);
+            if (technicianIndex == -1)
+            {
+                throw std::runtime_error("Invalid Technician ID");
+            }
+            User* technician = users.getValueAt(technicianIndex);
+            if (technician->getUserType() != util::UserType::TECHNICIAN)
+            {
+                throw std::runtime_error("User is not a technician");
+            }
+            booking->setAssignedTechnician(technician);
+        }
+        serviceBookings[booking->getId()] = booking;
     }
-    auto& trackedNotificationsMap = m_dataStore.getNotifications();
-    trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
-    m_dataStore.saveNotifications();
+}
+
+/*
+Function: saveServiceBookings
+Description: Saves service bookings from the datastore to persistent storage.
+             Uses FileManager to serialize bookings into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void ServiceManagementService::saveServiceBookings()
+{
+    util::FileManager<ServiceBooking> bookingFileManager(config::file::SERVICEBOOKING_FILE);
+    auto& serviceBookings = m_dataStore.getServiceBookings();
+    bookingFileManager.save(serviceBookings);
+}
+
+/*
+Function: loadJobCards
+Description: Loads job cards from persistent storage into the datastore.
+             Validates associated bookings, services, and technicians before
+             attaching them to each job card.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a booking ID, service ID, or technician ID is invalid
+    - std::runtime_error if a service does not belong to the booking
+    - std::runtime_error if a user is not a technician
+*/
+void ServiceManagementService::loadJobCards()
+{
+    util::FileManager<JobCard> jobCardFileManager(config::file::JOBCARD_FILE);
+    auto& jobCards = m_dataStore.getJobCards();
+    auto& serviceBookings = m_dataStore.getServiceBookings();
+    auto& services = m_dataStore.getServices();
+    auto& users = m_dataStore.getUsers();
+    auto jobCardsMap = jobCardFileManager.load();
+    for (int jobCardIndex = 0; jobCardIndex < jobCardsMap.getSize(); jobCardIndex++)
+    {
+        JobCard* jobCard = jobCardsMap.getValueAt(jobCardIndex);
+        int bookingIndex = serviceBookings.find(jobCard->getBookingId());
+        if (bookingIndex == -1)
+        {
+            throw std::runtime_error("Invalid Booking ID");
+        }
+        ServiceBooking* booking = serviceBookings.getValueAt(bookingIndex);
+        jobCard->setBooking(booking);
+        int serviceIndex = services.find(jobCard->getServiceId());
+        if (serviceIndex == -1)
+        {
+            throw std::runtime_error("Invalid Service ID");
+        }
+        Service* service = services.getValueAt(serviceIndex);
+        if (booking->getServices().find(jobCard->getServiceId()) == -1)
+        {
+            throw std::runtime_error("Service does not belong to booking");
+        }
+        jobCard->setService(service);
+        int technicianIndex = users.find(jobCard->getTechnicianId());
+        if (technicianIndex == -1)
+        {
+            throw std::runtime_error("Invalid Technician ID");
+        }
+        User* technician = users.getValueAt(technicianIndex);
+        if (technician->getUserType() != util::UserType::TECHNICIAN)
+        {
+            throw std::runtime_error("User is not a technician");
+        }
+        jobCard->setTechnician(technician);
+        jobCards[jobCard->getId()] = jobCard;
+    }
+}
+
+/*
+Function: saveJobCards
+Description: Saves job cards from the datastore to persistent storage.
+             Uses FileManager to serialize job cards into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void ServiceManagementService::saveJobCards()
+{
+    util::FileManager<JobCard> jobCardFileManager(config::file::JOBCARD_FILE);
+    auto& jobCards = m_dataStore.getJobCards();
+    jobCardFileManager.save(jobCards);
+}
+
+/*
+Function: loadObservers
+Description: Loads observer IDs from persistent storage and attaches corresponding
+             users as observers to the ServiceManagementService.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if an observer ID is invalid (not found in datastore)
+*/
+void ServiceManagementService::loadObservers()
+{
+    util::loadObservers(config::file::SERVICEMANAGEMENTOBSERVERS, this, m_dataStore);
+}
+
+/*
+Function: saveObservers
+Description: Saves the current observer IDs of the ServiceManagementService
+             to persistent storage for future retrieval.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void ServiceManagementService::saveObservers()
+{
+    util::saveObservers(config::file::SERVICEMANAGEMENTOBSERVERS, this);
 }
 
 /*
@@ -208,7 +514,7 @@ Description: Restores inventory quantities for all required items in the service
 Parameter: ServiceBooking* booking - Pointer to the booking whose inventory items need to be restored
 Return type: void
 */
-static void restoreInventory(ServiceBooking* booking, util::Map<std::string, TrackedRecord<InventoryItem>>& trackedInventoryItems)
+static void restoreInventory(ServiceBooking* booking)
 {
     const int INCREMENT_VALUE = 1;
     if (!booking) 
@@ -227,17 +533,9 @@ static void restoreInventory(ServiceBooking* booking, util::Map<std::string, Tra
         for (int InventoryIterator = 0; InventoryIterator < items.getSize(); ++InventoryIterator)
         {
             InventoryItem* item = items.getValueAt(InventoryIterator);
-            const std::string& currentItemId = item->getId();
-            int itemIndex = trackedInventoryItems.find(currentItemId);
-            if (itemIndex == -1)
-            {
-                continue;
-            }
-            auto& currentTrackedInventoryItem = trackedInventoryItems.getValueAt(itemIndex);
             if (item)
             {
                 item->setQuantity(item->getQuantity() + INCREMENT_VALUE);
-                currentTrackedInventoryItem.state = RecordState::MODIFIED;
             }
         }
     }
@@ -255,28 +553,23 @@ Parameters:
     util::UserType userType - Type of user initiating cancellation (CUSTOMER or TECHNICIAN)
 Return type: void
 */
-static void processBookingCancellation(TrackedRecord<ServiceBooking>& trackedBooking,
-    util::Map<std::string, TrackedRecord<JobCard>>& jobs,
+static void processBookingCancellation(ServiceBooking* booking,
+    util::Map<std::string, JobCard*>& jobs,
     ServiceManagementService& currentService,
-    util::UserType userType,
-    util::Map<std::string, TrackedRecord<InventoryItem>>& trackedInventoryItems)
+    util::UserType userType)
 {
-    ServiceBooking* booking = trackedBooking.data;
     if (!booking)
     {
         return;
     }
-    const std::string& bookingId = booking->getId();
     for (int jobIterator = 0; jobIterator < jobs.getSize(); ++jobIterator)
     {
-        auto& trackedJobCard = jobs.getValueAt(jobIterator);
-        JobCard* jobCard = trackedJobCard.data;
+        JobCard* jobCard = jobs.getValueAt(jobIterator);
         if (!jobCard || jobCard->getBookingId() != booking->getId() || jobCard->getStatus() == util::ServiceJobStatus::CANCELLED)
         {
             continue;
         }
         jobCard->setStatus(util::ServiceJobStatus::CANCELLED);
-        trackedJobCard.state = RecordState::MODIFIED;
         if (userType == util::UserType::CUSTOMER)
         {
             if (User* technician = booking->getAssignedTechnician())
@@ -309,8 +602,7 @@ static void processBookingCancellation(TrackedRecord<ServiceBooking>& trackedBoo
     }
     booking->setAssignedTechnician(nullptr);
     booking->setAssignedTechnicianId("");
-    trackedBooking.state = RecordState::MODIFIED;
-    restoreInventory(booking, trackedInventoryItems);
+    restoreInventory(booking);
 }
 
 /*
@@ -323,25 +615,22 @@ Return type: void
 */
 void ServiceManagementService::cancelCustomerServiceBookings(const std::string& customerID)
 {
-    DataStoreLockGuard lock(m_dataStore);
-    auto& trackedUsers = m_dataStore.getUsers();
-    int userIndex = trackedUsers.find(customerID);
+    auto& users = m_dataStore.getUsers();
+    int userIndex = users.find(customerID);
     if (userIndex == -1)
     {
         throw std::runtime_error("User not found: " + customerID);
     }
-    User* customer = trackedUsers.getValueAt(userIndex).data;
+    User* customer = users.getValueAt(userIndex);
     if (!customer)
     {
         throw std::runtime_error("User not found: " + customerID);
     }
-    auto& trackedBookings = m_dataStore.getServiceBookings();
-    auto& trackedJobs = m_dataStore.getJobCards();
-    auto& trackedInventoryItems = m_dataStore.getInventoryItems();
-    for (int iteratorOne = 0; iteratorOne < trackedBookings.getSize(); iteratorOne++)
+    auto& bookings = m_dataStore.getServiceBookings();
+    auto& jobs = m_dataStore.getJobCards();
+    for (int iteratorOne = 0; iteratorOne < bookings.getSize(); iteratorOne++)
     {
-        auto& trackedBooking = trackedBookings.getValueAt(iteratorOne);
-        ServiceBooking* booking = trackedBooking.data;
+        ServiceBooking* booking = bookings.getValueAt(iteratorOne);
         if (!booking)
         {
             continue;
@@ -356,12 +645,8 @@ void ServiceManagementService::cancelCustomerServiceBookings(const std::string&
         {
             continue;
         }
-        processBookingCancellation(trackedBooking, trackedJobs, *this, util::UserType::CUSTOMER, trackedInventoryItems);
+        processBookingCancellation(booking, jobs, *this, util::UserType::CUSTOMER);
     }
-    m_dataStore.saveUsers();
-    m_dataStore.saveServiceBookings();
-    m_dataStore.saveJobCards();
-    m_dataStore.saveInventoryItems();
 }
 
 /*
@@ -373,25 +658,22 @@ Return type: void
 */
 void ServiceManagementService::cancelTechnicianJobs(const std::string& technicianID)
 {
-    DataStoreLockGuard lock(m_dataStore);
-    auto& trackedUsers = m_dataStore.getUsers();
-    int userIndex = trackedUsers.find(technicianID);
+    auto& users = m_dataStore.getUsers();
+    int userIndex = users.find(technicianID);
     if (userIndex == -1)
     {
         throw std::runtime_error("User not found: " + technicianID);
     }
-    User* technician = trackedUsers.getValueAt(userIndex).data;
+    User* technician = users.getValueAt(userIndex);
     if (!technician)
     {
         throw std::runtime_error("User not found: " + technicianID);
     }
-    auto& trackedBookings = m_dataStore.getServiceBookings();
-    auto& trackedJobs = m_dataStore.getJobCards();
-    auto& trackedInventoryItems = m_dataStore.getInventoryItems();
-    for (int iteratorOne = 0; iteratorOne < trackedBookings.getSize(); iteratorOne++)
+    auto& bookings = m_dataStore.getServiceBookings();
+    auto& jobs = m_dataStore.getJobCards();
+    for (int iteratorOne = 0; iteratorOne < bookings.getSize(); iteratorOne++)
     {
-        auto& trackedBooking = trackedBookings.getValueAt(iteratorOne);
-        ServiceBooking* booking = trackedBooking.data;
+        ServiceBooking* booking = bookings.getValueAt(iteratorOne);
         if (!booking)
         {
             continue;
@@ -412,12 +694,8 @@ void ServiceManagementService::cancelTechnicianJobs(const std::string& technicia
         {
             continue;
         }
-        processBookingCancellation(trackedBooking, trackedJobs, *this, util::UserType::TECHNICIAN, trackedInventoryItems);
+        processBookingCancellation(booking, jobs, *this, util::UserType::TECHNICIAN);
     }
-    m_dataStore.saveUsers();
-    m_dataStore.saveInventoryItems();
-    m_dataStore.saveServiceBookings();
-    m_dataStore.saveJobCards();
 }
 
 /*
@@ -431,7 +709,6 @@ Return type: void
 */
 void ServiceManagementService::createComboPackage(const std::string& packageName, const util::Vector<std::string>& serviceIDsInNewCombo, double discountPercentage)
 {
-    DataStoreLockGuard lock(m_dataStore);
     if (packageName.empty())
     {
         throw std::invalid_argument("The Combo Package Name cannot be empty.\n");
@@ -444,19 +721,19 @@ void ServiceManagementService::createComboPackage(const std::string& packageName
     {
         throw std::invalid_argument("Discount percentage must be between 0 and 100.");
     }
-    auto& trackedServicesMap = m_dataStore.getServices();
+    auto& servicesMap = m_dataStore.getServices();
     for (int index = 0; index < serviceIDsInNewCombo.getSize(); index++)
     {
-        const std::string& serviceid = serviceIDsInNewCombo[index];
-        if (trackedServicesMap.find(serviceid) == -1)
+        const std::string serviceid = serviceIDsInNewCombo[index];
+        if (servicesMap.find(serviceid) == -1)
         {
             throw std::runtime_error("Service ID not found: " + serviceid);
         }
     }
-    auto& trackedComboPackageMap = m_dataStore.getComboPackages();
-    for (int iterator = 0; iterator < trackedComboPackageMap.getSize(); iterator++)
+    auto& comboPackageMap = m_dataStore.getComboPackages();
+    for (int iterator = 0; iterator < comboPackageMap.getSize(); iterator++)
     {
-        ComboPackage* existingCombos = trackedComboPackageMap.getValueAt(iterator).data;
+        ComboPackage* existingCombos = comboPackageMap.getValueAt(iterator);
         const util::Map<std::string, Service*>& servicesInsideExistingCombos = existingCombos->getServices();
         if (servicesInsideExistingCombos.getSize() == serviceIDsInNewCombo.getSize())
         {
@@ -480,16 +757,15 @@ void ServiceManagementService::createComboPackage(const std::string& packageName
     for (int iteratorOne = 0; iteratorOne < serviceIDsInNewCombo.getSize(); iteratorOne++)
     {
         const std::string& serviceId = serviceIDsInNewCombo[iteratorOne];
-        int serviceIndex = trackedServicesMap.find(serviceId);
+        int serviceIndex = servicesMap.find(serviceId);
         if (serviceIndex == -1)
         {
             throw std::runtime_error("Service ID not found: " + serviceId);
         }
-        selectedServices.insert(serviceId, trackedServicesMap.getValueAt(serviceIndex).data);
+        selectedServices.insert(serviceId, servicesMap.getValueAt(serviceIndex));
     }
     ComboPackage* newComboPackage = Factory::getObject<ComboPackage>(packageName, discountPercentage, selectedServices);
-    trackedComboPackageMap.insert(newComboPackage->getId(), util::createNewRecord(newComboPackage));
-    m_dataStore.saveComboPackages();
+    comboPackageMap.insert(newComboPackage->getId(), newComboPackage);
 }
 
 /*
@@ -500,10 +776,7 @@ Return type: util::Map<std::string, ComboPackage*>
 */
 util::Map<std::string, ComboPackage*> ServiceManagementService::getComboPackages()
 {
-    DataStoreLockGuard lock(m_dataStore);
-    util::Map<std::string, ComboPackage*> comboPackages;
-    comboPackages = util::getObjects(m_dataStore.getComboPackages());
-    return comboPackages;
+    return m_dataStore.getComboPackages();
 }
 
 /*
@@ -514,17 +787,14 @@ Return type: void
 */
 void ServiceManagementService::removeComboPackage(const std::string& comboPackageID)
 {
-    DataStoreLockGuard lock(m_dataStore);
     bool removed = false;
-    auto& trackedComboPackages = m_dataStore.getComboPackages();
-    for (int iterator = 0; iterator < trackedComboPackages.getSize(); iterator++)
+    util::Map<std::string, ComboPackage*>& currentComboPackages = m_dataStore.getComboPackages();
+    for (int iterator = 0; iterator < currentComboPackages.getSize(); iterator++)
     {
-        auto& comboPackage = trackedComboPackages.getValueAt(iterator);
-        ComboPackage* currentComboPackage = comboPackage.data;
+        ComboPackage* currentComboPackage = currentComboPackages.getValueAt(iterator);
         if (currentComboPackage && currentComboPackage->getId() == comboPackageID)
         {
             currentComboPackage->setState(util::State::INACTIVE);
-            comboPackage.state = RecordState::MODIFIED;
             removed = true;
             break;
         }
@@ -533,7 +803,6 @@ void ServiceManagementService::removeComboPackage(const std::string& comboPackag
     {
         throw std::runtime_error("Combo package with ID '" + comboPackageID + "' not found.");
     }
-    m_dataStore.saveComboPackages();
 }
 
 /*
@@ -546,10 +815,7 @@ Returns:
 */
 util::Map<std::string, ServiceBooking*> ServiceManagementService::getServiceBookings()
 {
-    DataStoreLockGuard lock(m_dataStore);
-    util::Map<std::string, ServiceBooking*> serviceBookings;
-    serviceBookings = util::getObjects(m_dataStore.getServiceBookings());
-    return serviceBookings;
+	return m_dataStore.getServiceBookings();
 }
 
 /*
@@ -588,10 +854,9 @@ Throws:
 */
 void ServiceManagementService::createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID)
 {
-    DataStoreLockGuard lock(m_dataStore);
 	UserManagementService m_userManagementService;
 	ServiceBooking* currentBooking = getServiceBooking(bookingID);
-	auto& currentTrackedJobCards = m_dataStore.getJobCards();
+	auto& currentJobCards = m_dataStore.getJobCards();
 	if (currentBooking == nullptr)
 	{
 		throw std::runtime_error("Service Booking not available");
@@ -637,7 +902,7 @@ void ServiceManagementService::createJobCard(const std::string& bookingID, const
 	JobCard* jobCard = Factory::getObject<JobCard>(bookingID, currentBooking, currentService, serviceID, technicianID, selectedTechnician, util::Timestamp(), util::ServiceJobStatus::STARTED, util::Timestamp());
 	if (jobCard)
 	{
-		currentTrackedJobCards.insert(jobCard->getId(), util::createNewRecord(jobCard));
+		currentJobCards.insert(jobCard->getId(), jobCard);
 		sendNotification(selectedTechnician, title, message);
 	}
 	else
@@ -647,7 +912,6 @@ void ServiceManagementService::createJobCard(const std::string& bookingID, const
     title = "Technician assigned";
     message = "A technician has been assigned to your Service Booking with ID " + bookingID;
     sendNotification(currentBooking->getCustomer(), title, message);
-    m_dataStore.saveJobCards();
 }
 
 /*
@@ -665,17 +929,15 @@ Throws:
 */
 void ServiceManagementService::createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost)
 {
-    DataStoreLockGuard lock(m_dataStore);
 	util::Map<std::string, InventoryItem*> currentServiceInventoryItems;
-	auto& trackedInventoryItems = m_dataStore.getInventoryItems();
-    auto& currentServices = m_dataStore.getServices();
+	auto inventoryItems = m_dataStore.getInventoryItems();
 	for (int iteratorOne =0; iteratorOne < inventoryItemIDs.getSize(); iteratorOne++)
 	{
 		std::string currentItemID = inventoryItemIDs[iteratorOne];
 		bool itemFound = false;
-		for (int iteratorTwo = 0; iteratorTwo < trackedInventoryItems.getSize(); iteratorTwo++)
+		for (int iteratorTwo = 0; iteratorTwo < inventoryItems.getSize(); iteratorTwo++)
 		{
-			InventoryItem* currentInventoryItem = trackedInventoryItems.getValueAt(iteratorTwo).data;
+			InventoryItem* currentInventoryItem = inventoryItems.getValueAt(iteratorTwo);
 			if (currentInventoryItem && currentInventoryItem->getId() == currentItemID)
 			{
 				itemFound = true;
@@ -693,12 +955,12 @@ void ServiceManagementService::createService(const std::string& name, const util
 	{
 		throw std::runtime_error("Unable to create new service.");
 	}
+	util::Map<std::string, Service*>& currentServices = m_dataStore.getServices();
 	if (currentServices.find(newService->getId()) != -1)
 	{
 		throw std::runtime_error("Service with this ID Already exists.");
 	}
-	currentServices.insert(newService->getId(), util::createNewRecord(newService));
-    m_dataStore.saveServices();
+	currentServices.insert(newService->getId(), newService);
 }
 
 /*
@@ -711,10 +973,7 @@ Returns:
 */
 util::Map<std::string, Service*> ServiceManagementService::getServices()
 {
-    DataStoreLockGuard lock(m_dataStore);
-    util::Map<std::string, Service*> services;
-    services = util::getObjects(m_dataStore.getServices());
-    return services;
+	return m_dataStore.getServices();
 }
 
 /*
@@ -729,19 +988,14 @@ Throws:
 */
 void ServiceManagementService::removeService(const std::string& serviceID)
 {
-    DataStoreLockGuard lock(m_dataStore);
-	auto& currentTrackedServices = m_dataStore.getServices();
-    auto& currentTrackedComboPackages =  m_dataStore.getComboPackages();
-	if (currentTrackedServices.find(serviceID) != -1)
+	util::Map<std::string, Service*>& currentServices = m_dataStore.getServices();
+    util::Map<std::string, ComboPackage*>& currentComboPackages =  m_dataStore.getComboPackages();
+	if (currentServices.find(serviceID) != -1)
 	{
-        int serviceIndex, comboPackageIndex;
-        serviceIndex = currentTrackedServices.find(serviceID);
-		currentTrackedServices.getValueAt(serviceIndex).data->setState(util::State::INACTIVE);
-        currentTrackedServices.getValueAt(serviceIndex).state = RecordState::MODIFIED;
-        for (int iterator = 0; iterator < currentTrackedComboPackages.getSize(); iterator++)
+		currentServices.getValueAt(currentServices.find(serviceID))->setState(util::State::INACTIVE);
+        for (int iterator = 0; iterator < currentComboPackages.getSize(); iterator++)
         {
-            comboPackageIndex = iterator;
-            ComboPackage* currentComboPackage = currentTrackedComboPackages.getValueAt(iterator).data;
+            ComboPackage* currentComboPackage = currentComboPackages.getValueAt(iterator);
             if (currentComboPackage && currentComboPackage->getState() == util::State::ACTIVE)
             {
                 util::Map<std::string, Service*> currentServices = currentComboPackage->getServices();
@@ -751,7 +1005,6 @@ void ServiceManagementService::removeService(const std::string& serviceID)
                     if (currentService->getId() == serviceID)
                     {
                         currentComboPackage->setState(util::State::INACTIVE);
-                        currentTrackedComboPackages.getValueAt(comboPackageIndex).state = RecordState::MODIFIED;
                         break;
                     }
                 }
@@ -762,8 +1015,6 @@ void ServiceManagementService::removeService(const std::string& serviceID)
 	{
 		throw std::runtime_error("Service not found.");
 	}
-    m_dataStore.saveServices();
-    m_dataStore.saveComboPackages();
 }
 
 /*
@@ -802,12 +1053,11 @@ Returns:
 */
 util::Map<std::string, JobCard*> ServiceManagementService::getJobCards(const std::string& technicianID)
 {
-    DataStoreLockGuard lock(m_dataStore);
-	auto& trackedJobCards = m_dataStore.getJobCards();
+	util::Map<std::string, JobCard*> jobCards = m_dataStore.getJobCards();
 	util::Map<std::string, JobCard*> technicianJobCards;
-	for (int iterator = 0; iterator < trackedJobCards.getSize(); iterator++)
+	for (int iterator = 0; iterator < jobCards.getSize(); iterator++)
 	{
-		JobCard* currentJobCard = trackedJobCards.getValueAt(iterator).data;
+		JobCard* currentJobCard = jobCards.getValueAt(iterator);
 		if (currentJobCard->getTechnicianId() == technicianID)
 		{
 			technicianJobCards.insert(currentJobCard->getId(), currentJobCard);
@@ -856,7 +1106,6 @@ Returns:
 */
 void ServiceManagementService::updateJobStatus(const std::string& jobID)
 {
-    DataStoreLockGuard lock(m_dataStore);
 	AuthenticationManagementService authenticationManagementService;
 	PaymentManagementService paymentManagementService;
 	bool jobStatusUpdated = false, serviceBookingCompleted;
@@ -871,15 +1120,8 @@ void ServiceManagementService::updateJobStatus(const std::string& jobID)
 	{
 		throw std::runtime_error("No job cards assigned to the technician.");
 	}
-    auto& trackedJobCards = m_dataStore.getJobCards();
-    auto& trackedServiceBookings = m_dataStore.getServiceBookings();
 	if (currentAssignedJobs.find(jobID) != -1)
 	{
-        int jobIndex = trackedJobCards.find(jobID);
-        if (jobIndex == -1)
-        {
-            throw std::runtime_error("Unable to fetch current job.");
-        }
 		currentJob = currentAssignedJobs.getValueAt(currentAssignedJobs.find(jobID));
 		if (currentJob == nullptr)
 		{
@@ -888,20 +1130,16 @@ void ServiceManagementService::updateJobStatus(const std::string& jobID)
 		if (currentJob->getStatus() == util::ServiceJobStatus::STARTED)
 		{
 			currentJob->setStatus(util::ServiceJobStatus::IN_PROGRESS);
-            trackedJobCards.getValueAt(jobIndex).state = RecordState::MODIFIED;
 			jobStatusUpdated = true;
 		}
         else if (currentJob->getStatus() == util::ServiceJobStatus::IN_PROGRESS)
         {
             currentJob->setStatus(util::ServiceJobStatus::COMPLETED);
-            trackedJobCards.getValueAt(jobIndex).state = RecordState::MODIFIED;
             jobStatusUpdated = true;
             serviceBookingCompleted = hasCompletedAllJobs(currentJob->getBookingId(), currentAssignedJobs);
             if (serviceBookingCompleted)
             {
-                const std::string& bookingId = currentJob->getBookingId();
                 currentJob->getBooking()->setStatus(util::ServiceJobStatus::COMPLETED);
-                trackedServiceBookings.getValueAt(trackedServiceBookings.find(bookingId)).state = RecordState::MODIFIED;
                 paymentManagementService.generateInvoice(currentJob->getBooking());
                 std::string title = "Service Booking completed. Invoice Generated.";
                 std::string message = "Services completed for the booking and invoice generated.";
@@ -917,6 +1155,4 @@ void ServiceManagementService::updateJobStatus(const std::string& jobID)
 	{
 		throw std::runtime_error("Failed to update job status. Job may already be completed.");
 	}
-    m_dataStore.saveJobCards();
-    m_dataStore.saveServiceBookings();
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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