changes

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

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

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

@@ -6,7 +6,6 @@ Description: Implementation file containing the method definitions of the
 Author: Trenser
 Date:19-May-2026
 */
-
 #include "ComboPackage.h"
 #include "Controller.h"
 #include "Enums.h"
@@ -588,37 +587,63 @@ void Controller::configureNotifications(bool paymentNotifications, bool serviceN
 }
 
 /*
-Function: initialize
+Function: loadSystemData
-Description: Initializes the system and run system checks to ensure critical configurations, such as verifying admin existence.
+Description: Loads all system data from persistent storage into memory.
-Parameters:
+             Invokes the respective management services to load users, inventory items, services,
-    - None
+             combo packages, service bookings, job cards, invoices, and observers.
-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
 Parameters:
     - None
 Returns:
     - void
 */
-void Controller::shutdown()
+void Controller::loadSystemData()
 {
-    auto& dataStore = DataStore::getInstance();
+    m_userManagementService.loadUsers();
-    dataStore.shutdown();
+    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 loadSystemData();
-    void shutdown();
+    void saveSystemData();
+    void runSystemChecks();
 };

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

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

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

@@ -20,12 +20,12 @@ class InventoryItem;
 class ServiceBooking;
 class JobCard;
 class Invoice;
+class Payment;
 
 class DataStore
 {
 private:
     DataStore();
-    ~DataStore();
     DataStore(const DataStore&) = delete;
     DataStore& operator=(const DataStore&) = delete;
     DataStore(DataStore&&) = delete;
@@ -40,43 +40,28 @@ private:
     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<User>> getUsers();
-    util::Map<std::string, TrackedRecord<Notification>>& getNotifications();
+    util::Map<std::string, TrackedRecord<Notification>> getNotifications();
-    util::Map<std::string, TrackedRecord<Service>>& getServices();
+    util::Map<std::string, TrackedRecord<Service>> getServices();
-    util::Map<std::string, TrackedRecord<ComboPackage>>& getComboPackages();
+    util::Map<std::string, TrackedRecord<ComboPackage>> getComboPackages();
-    util::Map<std::string, TrackedRecord<InventoryItem>>& getInventoryItems();
+    util::Map<std::string, TrackedRecord<InventoryItem>> getInventoryItems();
-    util::Map<std::string, TrackedRecord<ServiceBooking>>& getServiceBookings();
+    util::Map<std::string, TrackedRecord<ServiceBooking>> getServiceBookings();
-    util::Map<std::string, TrackedRecord<JobCard>>& getJobCards();
+    util::Map<std::string, TrackedRecord<JobCard>> getJobCards();
-    util::Map<std::string, TrackedRecord<Invoice>>& getInvoices();
+    util::Map<std::string, TrackedRecord<Invoice>> getInvoices();
-    util::Map<std::string, User*> getServiceManagementObservers();
+    util::Map<std::string, TrackedRecord<Payment>> getPayments();
-    util::Map<std::string, User*> getPaymentManagementObservers();
+    void saveUsers(util::Map<std::string, TrackedRecord<User>>& users);
-    util::Map<std::string, User*> getInventoryManagementObservers();
+    void saveNotifications(util::Map<std::string, TrackedRecord<Notification>>& notifications);
-    void saveUsers();
+    void saveServices(util::Map<std::string, TrackedRecord<Service>>& services);
-    void saveNotifications();
+    void saveComboPackages(util::Map<std::string, TrackedRecord<ComboPackage>>& comboPackages);
-    void saveServices();
+    void saveInventoryItems(util::Map<std::string, TrackedRecord<InventoryItem>>& inventoryItems);
-    void saveComboPackages();
+    void saveServiceBookings(util::Map<std::string, TrackedRecord<ServiceBooking>>& bookings);
-    void saveInventoryItems();
+    void saveJobCards(util::Map<std::string, TrackedRecord<JobCard>>& jobCards);
-    void saveServiceBookings();
+    void saveInvoices(util::Map<std::string, TrackedRecord<Invoice>>& invoices);
-    void saveJobCards();
+    void savePayments(util::Map<std::string, TrackedRecord<Payment>>& payments);
-    void saveInvoices();
-    void saveServiceManagementObservers(util::Map<std::string, User*>& observers);
-    void savePaymentManagementObservers(util::Map<std::string, User*>& observers);
-    void saveInventoryManagementObservers(util::Map<std::string, User*>& observers);
     bool lockDataStore();
     bool unlockDataStore();
 private:
@@ -84,154 +69,4 @@ 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);
 };
-
-/*
-Function: loadRecords
-Description: Loads all serialized records from the specified
-             shared-memory mapping, deserializes them into
-             application objects, and returns them as a map
-             of tracked records. Each loaded record is marked
-             as CLEAN and assigned its corresponding slot index
-             within the mapping so that future modifications
-             can be written back efficiently.
-Parameter:
-    - mapping: Reference to the mapping containing the
-               serialized records.
-Return type:
-    util::Map<std::string, TrackedRecord<TObject>>
-             A map containing all loaded records keyed by
-             their unique identifier.
-*/
-template<typename TObject, typename TSerialized>
-util::Map<std::string, TrackedRecord<TObject>> DataStore::loadRecords(MappingInfo& mapping)
-{
-    util::Map<std::string, TrackedRecord<TObject>> records;
-    SharedMemory::ensureLatestMapping(mapping);
-    size_t recordCount = SharedMemory::getRecordCount(mapping);
-    for (size_t index = 0; index < recordCount; ++index)
-    {
-        TSerialized* serialized = static_cast<TSerialized*>(SharedMemory::getRecordAddress(mapping,index));
-        TObject* object = TObject::deserialize(*serialized);
-        TrackedRecord<TObject> trackedRecord;
-        trackedRecord.data = object;
-        trackedRecord.state = RecordState::CLEAN;
-        trackedRecord.slotIndex = index;
-        records.insert(object->getId(), trackedRecord);
-    }
-    return records;
-}
-
-/*
-Function: saveRecords
-Description: Persists all modified and newly added records
-             contained in the provided map to the specified
-             shared-memory mapping. Modified records overwrite
-             their existing slots, while new records are
-             appended to the end of the mapping. Records marked
-             as CLEAN are ignored.
-Parameter:
-    - mapping: Reference to the mapping where records are
-               stored.
-    - records: Map containing the records to be persisted.
-Return type: void
-*/
-template<typename TObject, typename TSerialized> void DataStore::saveRecords(MappingInfo& mapping, util::Map<std::string, TrackedRecord<TObject>>& records)
-{
-    SharedMemory::ensureLatestMapping(mapping);
-    for (int index = 0; index < records.getSize(); ++index)
-    {
-        TrackedRecord<TObject>& record = records.getValueAt(index);
-        if (record.state == RecordState::CLEAN)
-        {
-            continue;
-        }
-        TSerialized serialized = record.data->serialize();
-        if (record.state == RecordState::MODIFIED)
-        {
-            TSerialized* destination = static_cast<TSerialized*>(SharedMemory::getRecordAddress(mapping, record.slotIndex));
-            if (destination)
-            {
-                *destination = serialized;
-            }
-        }
-        else if (record.state == RecordState::NEW_RECORD)
-        {
-            if (!SharedMemory::ensureCapacityForInsert(mapping))
-            {
-                continue;
-            }
-            size_t recordCount = SharedMemory::getRecordCount(mapping);
-            TSerialized* destination = static_cast<TSerialized*>(SharedMemory::getRecordAddress(mapping,recordCount));
-            *destination = serialized;
-            SharedMemory::setRecordCount(mapping, recordCount + 1);
-            record.slotIndex = recordCount;
-        }
-        record.state = RecordState::CLEAN;
-    }
-}
-
-/*
-Function: clearCache
-Description: Releases all objects owned by the cache and
-             clears the cache contents.
-Parameters:
-    - cache: Cache to be cleared.
-Returns:
-    - None
-*/
-template<typename TObject>
-void DataStore::clearCache(util::Map<std::string, TrackedRecord<TObject>>&cache)
-{
-    for (int index = 0; index < cache.getSize(); ++index)
-    {
-        delete cache.getValueAt(index).data;
-        cache.getValueAt(index).data = nullptr;
-    }
-    cache.clear();
-}
-
-/*
-Function: refreshCache
-Description: Refreshes the cache while preserving object addresses
-             for records that already exist. Existing objects are
-             updated in-place so that pointers held elsewhere remain
-             valid after the refresh.
-Parameters:
-    - cache: Existing cache to refresh.
-    - refreshedCache: Newly loaded cache contents.
-Returns:
-    - None
-*/
-template<typename TObject>
-void DataStore::refreshCache(util::Map<std::string, TrackedRecord<TObject>>& cache, util::Map<std::string, TrackedRecord<TObject>>& refreshedCache)
-{
-    util::Map<std::string, TrackedRecord<TObject>> oldCache = cache;
-    cache.clear();
-    for (int index = 0; index < refreshedCache.getSize(); ++index)
-    {
-        const std::string& id = refreshedCache.getKeyAt(index);
-        TrackedRecord<TObject>& refreshedRecord = refreshedCache.getValueAt(index);
-        int oldIndex = oldCache.find(id);
-        if (oldIndex != -1)
-        {
-            TrackedRecord<TObject>& oldRecord = oldCache.getValueAt(oldIndex);
-            *oldRecord.data = *refreshedRecord.data;
-            oldRecord.slotIndex = refreshedRecord.slotIndex;
-            oldRecord.state = refreshedRecord.state;
-            delete refreshedRecord.data;
-            refreshedRecord.data = oldRecord.data;
-        }
-        cache.insert(id, refreshedRecord);
-    }
-    for (int index = 0; index < oldCache.getSize(); ++index)
-    {
-        const std::string& id = oldCache.getKeyAt(index);
-        if (cache.find(id) == -1)
-        {
-            delete oldCache.getValueAt(index).data;
-        }
-    }
-}

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/FileHeader.h

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

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

@@ -1,13 +1,3 @@
-/*
-File: MappingInfo.h
-Description: Defines the MappingInfo structure used for
-             managing Windows file mapping operations.
-             Stores handles, mapped view pointer,
-             file metadata, and capacity information.
-Author: Trenser
-Created: 10-June-2026
-*/
-
 #pragma once
 #include <windows.h>
 #include <string>

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

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

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

@@ -1,15 +1,3 @@
-/*
-File: SerializedRecords.h
-Description: Defines serialized structures for persistent storage
-             and retrieval of system entities including User,
-             Notification, Service, ComboPackage, InventoryItem,
-             ServiceBooking, JobCard, Invoice, and Observer.
-             These structures use fixed-size character arrays
-             and primitive types for binary serialization.
-Author: Trenser
-Created: 10-June-2026
-*/
-
 #pragma once
 #include "Utility.h"
 #include "Enums.h"
@@ -34,7 +22,6 @@ struct SerializedNotification
     char title[128];
     char message[1024];
     util::Timestamp createdAt;
-    util::State state;
 };
 
 struct SerializedService
@@ -102,8 +89,3 @@ struct SerializedInvoice
     util::PaymentMode paymentMethod;
     util::PaymentStatus status;
 };
-
-struct SerializedObserver
-{
-    char id[64];
-};

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

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

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

@@ -1,14 +1,3 @@
-/*
-File: SharedMemory.h
-Description: Declares functions for managing Windows file
-             mapping and shared memory operations. Provides
-             utilities for creating, resizing, and closing
-             mappings, as well as accessing headers and
-             record data.
-Author: Trenser
-Created: 10-June-2026
-*/
-
 #pragma once
 #include <cstddef>
 #include "MappingInfo.h"
@@ -26,4 +15,5 @@ namespace SharedMemory
     void setRecordCount(MappingInfo& mapping, size_t count);
     size_t getCapacity(MappingInfo& mapping);
     bool ensureCapacityForInsert(MappingInfo& mapping);
+    bool shrinkIfNeeded(MappingInfo& mapping);
 };

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

@@ -1,13 +1,3 @@
-/*
-File: TrackedRecord.h
-Description: Defines the TrackedRecord template structure used
-             to manage objects with associated record state and
-             slot index. Supports tracking of CLEAN, NEW_RECORD,
-             and MODIFIED states for persistence and synchronization.
-Author: Trenser
-Created: 10-June-2026
-*/
-
 #pragma once
 #include "RecordState.h"
 

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

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

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

@@ -8,6 +8,7 @@ Date: 19-May-2026
 
 #include <sstream>
 #include <stdexcept>
+#include "SerializedRecords.h"
 #include "Factory.h"
 #include "StringHelper.h"
 #include "InventoryItem.h"
@@ -206,73 +207,37 @@ void InventoryItem::setState(util::State status)
 
 /*
 Function: serialize
-Description: Serializes the inventory item into a CSV-formatted string.
+Description: Serializes the InventoryItem object into a SerializedInventoryItem record.
 Parameters:
     - None
 Returns:
-    - std::string: Serialized inventory item record
+    - SerializedInventoryItem: Serialized representation of the inventory item
 */
-std::string InventoryItem::serialize() const
+SerializedInventoryItem InventoryItem::serialize() const
 {
-    std::ostringstream serializedInventoryItem;
+    SerializedInventoryItem serialized = {};
-    serializedInventoryItem << m_id << ','
+    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
-        << m_partName << ','
+    strcpy_s(serialized.partName, sizeof(serialized.partName), m_partName.c_str());
-        << m_quantity << ','
+    serialized.quantity = m_quantity;
-        << m_price << ','
+    serialized.price = m_price;
-        << util::getStateString(m_status);
+    serialized.status = m_status;
-    return serializedInventoryItem.str();
+    return serialized;
 }
 
 /*
 Function: deserialize
-Description: Deserializes a CSV-formatted string into an InventoryItem object.
+Description: Deserializes a SerializedInventoryItem record into an InventoryItem object.
 Parameters:
-    - record: const std::string&, serialized inventory item record
+    - serializedInventoryItem: const SerializedInventoryItem&, serialized inventory item record
 Returns:
     - InventoryItem*: Pointer to the deserialized InventoryItem object
-Throws:
-    - std::runtime_error if data is invalid
 */
-InventoryItem* InventoryItem::deserialize(const std::string& record)
+InventoryItem* InventoryItem::deserialize(const SerializedInventoryItem& serializedInventoryItem)
 {
-    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>(
-        id,
+        serializedInventoryItem.id,
-        partName,
+        serializedInventoryItem.partName,
-        quantity,
+        serializedInventoryItem.quantity,
-        price,
+        serializedInventoryItem.price,
-        status
+        serializedInventoryItem.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,11 +6,12 @@ Author: Trenser
 Date: 19-May-2026
 */
 
-
 #pragma once
 #include <string>
 #include "Enums.h"
 
+struct SerializedInventoryItem;
+
 class InventoryItem
 {
 private:
@@ -34,7 +35,6 @@ public:
     void setQuantity(int quantity);
     void setPrice(double price);
     void setState(util::State status);
-    std::string serialize() const;
+    SerializedInventoryItem serialize() const;
-    static InventoryItem* deserialize(const std::string&);
+    static InventoryItem* deserialize(const SerializedInventoryItem&);
-    static std::string getHeaders();
 };

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

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

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

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

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

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

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

@@ -7,6 +7,7 @@ Date: 19-May-2026
 */
 
 #include <sstream>
+#include "SerializedRecords.h"
 #include "Notification.h"
 #include "StringHelper.h"
 #include "Factory.h"
@@ -219,69 +220,37 @@ void Notification::setCreatedAt(const util::Timestamp& createdAt)
 
 /*
 Function: serialize
-Description: Serializes the notification into a CSV-formatted string.
+Description: Serializes the Notification object into a SerializedNotification record.
 Parameters:
     - None
 Returns:
-    - std::string: Serialized notification record
+    - SerializedNotification: Serialized representation of the notification
 */
-std::string Notification::serialize() const
+SerializedNotification Notification::serialize() const
 {
-    std::ostringstream serializedNotification;
+    SerializedNotification serialized = {};
-    serializedNotification << m_id << ','
+    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
-        << m_recipientUserId << ','
+    strcpy_s(serialized.recipientUserId, sizeof(serialized.recipientUserId), m_recipientUserId.c_str());
-        << m_title << ','
+    strcpy_s(serialized.title, sizeof(serialized.title), m_title.c_str());
-        << m_message << ','
+    strcpy_s(serialized.message, sizeof(serialized.message), m_message.c_str());
-        << m_createdAt.toString();
+    serialized.createdAt = m_createdAt;
-    return serializedNotification.str();
+    return serialized;
 }
 
 /*
 Function: deserialize
-Description: Deserializes a CSV-formatted string into a Notification object.
+Description: Deserializes a SerializedNotification record into a Notification object.
 Parameters:
-    - record: const std::string&, serialized notification record
+    - serializedNotification: const SerializedNotification&, serialized notification record
 Returns:
     - Notification*: Pointer to the deserialized Notification object
-Throws:
-    - std::runtime_error if timestamp parsing fails
 */
-Notification* Notification::deserialize(const std::string& record)
+Notification* Notification::deserialize(const SerializedNotification& serializedNotification)
 {
-    std::string id, recipientUserId, title, message, createdAtTimestampString;
-    std::istringstream serializedNotification(record);
-    getline(serializedNotification, id, ',');
-    getline(serializedNotification, recipientUserId, ',');
-    getline(serializedNotification, title, ',');
-    getline(serializedNotification, message, ',');
-    getline(serializedNotification, createdAtTimestampString, ',');
-    util::Timestamp createdAtTimestamp;
-    try
-    {
-        createdAtTimestamp = util::Timestamp::fromString(createdAtTimestampString);
-    }
-    catch (...)
-    {
-        throw std::runtime_error("Invalid createdAt timestamp");
-    }
     return Factory::getObject<Notification>(
-        id,
+        serializedNotification.id,
-        recipientUserId,
+        serializedNotification.recipientUserId,
-        title,
+        serializedNotification.title,
-        message,
+        serializedNotification.message,
-        createdAtTimestamp
+        serializedNotification.createdAt);
-    );
-}
-
-/*
-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

@@ -11,6 +11,7 @@ Date: 19-May-2026
 #include "Timestamp.h"
 
 class User;
+struct SerializedNotification;
 
 class Notification
 {
@@ -38,7 +39,6 @@ public:
     void setTitle(const std::string& title);
     void setMessage(const std::string& message);
     void setCreatedAt(const util::Timestamp& createdAt);
-    std::string serialize() const;
+    SerializedNotification serialize() const;
-    static Notification* deserialize(const std::string&);
+    static Notification* deserialize(const SerializedNotification&);
-    static std::string getHeaders();
 };

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

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

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

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

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

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

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

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

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

@@ -29,8 +29,7 @@ Returns:
 User::User()
     : m_id("USR" + std::to_string(++m_uid)),
     m_type(util::UserType::CUSTOMER),
-    m_status(util::State::ACTIVE) {
+    m_status(util::State::ACTIVE) {}
-}
 
 /*
 Function: User
@@ -53,8 +52,7 @@ User::User(const std::string& userName, const std::string& password, const std::
     m_phone(phone),
     m_email(email),
     m_type(role),
-    m_status(util::State::ACTIVE) {
+    m_status(util::State::ACTIVE) {}
-}
 
 /*
 Function: User (parameterized constructor with ID)

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

@@ -20,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
@@ -34,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;
@@ -77,9 +73,7 @@ void UserManagementService::createUser(const std::string& username, const std::s
 	InventoryManagementService inventoryManagementService;
 	PaymentManagementService paymentManagementService;
 	ServiceManagementService serviceManagementService;
-	DataStoreLockGuard lock(m_dataStore);
+	auto& usersMap = m_dataStore.getUsers();
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	auto usersMap = util::getObjects(trackedUsersMap);
 	if (util::isUsernameDuplicate(username, usersMap))
 	{
 		throw std::runtime_error("Username already exists");
@@ -93,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();
 }
 
 /*
@@ -114,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& usersMap = m_dataStore.getUsers();
-	auto& trackedUsersMap = m_dataStore.getUsers();
+	int index = usersMap.find(userID);
-	auto usersMap = util::getObjects(trackedUsersMap);
-	int index = trackedUsersMap.find(userID);
 	if (index == -1)
 	{
 		throw std::runtime_error("User does not exist!\n");
 	}
-	User* user = trackedUsersMap.getValueAt(index).data;
+	User* user = usersMap.getValueAt(index);
-	bool isModified = false;
 	if (email != user->getEmail())
 	{
 		if (util::isEmailDuplicate(email, usersMap))
 		{
 			throw std::runtime_error("Email already exists!\n");
 		}
-		user->setEmail(email);
-		isModified = true;
 	}
 	if (phone != user->getPhone())
 	{
@@ -139,14 +127,9 @@ void UserManagementService::updateUserDetails(const std::string& userID, const s
 		{
 			throw std::runtime_error("Phone number already exists!\n");
 		}
+	}
+	user->setEmail(email);
 	user->setPhone(phone);
-		isModified = true;
-	}
-	if (isModified)
-	{
-		trackedUsersMap.getValueAt(index).state = RecordState::MODIFIED;
-		m_dataStore.saveUsers();
-	}
 }
 
 /*
@@ -161,13 +144,12 @@ Throws:
 */
 util::Vector<Notification*> UserManagementService::getUserNotifications(const std::string& userID)
 {
-	DataStoreLockGuard lock(m_dataStore);
+	auto& usersMap = m_dataStore.getUsers();
-	auto& trackedUsersMap = m_dataStore.getUsers(); 
+	if (usersMap.find(userID) == -1)
-	if (trackedUsersMap.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& notifications = user->getNotifications();
@@ -187,41 +169,97 @@ util::Vector<Notification*> UserManagementService::getUserNotifications(const st
 
 /*
 Function: deleteNotification
-Description: Marks a specific notification associated with a given user
+Description: Deletes a specific notification associated with a given user ID.
-			 as inactive.
 Parameters:
 	- notificationID: The unique ID of the notification to be deleted.
 	- userID: The unique ID of the user whose notification is to be deleted.
 Returns:
 	- void
 Throws:
-	- std::runtime_error if no user is found with the given UserID or
+	- std::runtime_error if no user is found with the given UserID or if no notification is found with the given NotificationID.
-	  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& usersMap = m_dataStore.getUsers();
-	auto& trackedUsersMap = m_dataStore.getUsers();
+	if (usersMap.find(userID) == -1)
-	auto& trackedNotificationsMap = m_dataStore.getNotifications();
-	int userIndex = trackedUsersMap.find(userID);
-	if (userIndex == -1)
 	{
 		throw std::runtime_error("No user found with given UserID");
 	}
-	User* user = trackedUsersMap.getValueAt(userIndex).data;
+	User* user = usersMap[userID];
 	auto& notifications = user->getNotifications();
 	if (notifications.find(notificationID) == -1)
 	{
 		throw std::runtime_error("No notification found with given NotificationID");
 	}
-	int notificationIndex = trackedNotificationsMap.find(notificationID);
+	notifications.remove(notificationID);
-	if (notificationIndex == -1)
+}
+
+/*
+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++)
     {
-		throw std::runtime_error("No notification found with given NotificationID");
+        users[usersMap.getKeyAt(index)] = usersMap.getValueAt(index);
     }
-	notifications[notificationID]->setState(util::State::INACTIVE);
+    for (int index = 0; index < numberOfNotifications; index++)
-	trackedNotificationsMap.getValueAt(notificationIndex).state = RecordState::MODIFIED;
+    {
-	m_dataStore.saveNotifications();
+        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);
 }
 
 /*
@@ -232,9 +270,7 @@ Return type: util::Map<std::string, User*>
 */
 util::Map<std::string, User*> UserManagementService::getUsers()
 {
-	DataStoreLockGuard lock(m_dataStore);
+	return m_dataStore.getUsers();
-	auto users = util::getObjects(m_dataStore.getUsers());
-	return users;
 }
 
 /*
@@ -245,12 +281,10 @@ Return type: User*
 */
 User* UserManagementService::getUser(const std::string& userID)
 {
-	DataStoreLockGuard lock(m_dataStore);
+	int index = m_dataStore.getUsers().find(userID);
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	int index = trackedUsersMap.find(userID);
 	if (index != -1)
 	{
-		return trackedUsersMap.getValueAt(index).data;
+		return m_dataStore.getUsers().getValueAt(index);
 	}
 	return nullptr;
 }
@@ -266,12 +300,10 @@ void UserManagementService::removeUser(const std::string& userID)
 	InventoryManagementService inventoryManagementService;
 	PaymentManagementService paymentManagementService;
 	ServiceManagementService serviceManagementService;
-	DataStoreLockGuard lock(m_dataStore);
+	int index = m_dataStore.getUsers().find(userID);
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	int index = trackedUsersMap.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)
@@ -282,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);
+	util::Map<std::string, User*>& currentUsers = m_dataStore.getUsers();
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	util::Map<std::string, User*> currentUsers = util::getObjects(trackedUsersMap);
 	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

@@ -6,7 +6,6 @@ Description: Header file declaring the UserManagementService class, which manage
 Author: Trenser
 Date:19-May-2026
 */
-
 #pragma once
 #include <string>
 #include "Map.h"
@@ -31,4 +30,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

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

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

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

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

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

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

@@ -30,6 +30,7 @@ Description: Displays the customer menu and handles user input until logout is s
 Parameter: None
 Return type: void
 */
+
 void CustomerMenu::showMenu()
 {
     while (true)

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

@@ -914,7 +914,7 @@ inline void changePasswordHelper(Controller& controller)
         util::clear();
         std::cout << "Change Password\n";
         std::cout << "Enter new password: ";
-        util::readPassword(newPassword);
+        util::read(newPassword);
         if (!util::isPasswordValid(newPassword))
         {
             std::cout << "Error: Password is not strong enough!\n";
@@ -928,7 +928,7 @@ inline void changePasswordHelper(Controller& controller)
             continue;
         }
         std::cout << "Confirm new password: ";
-        util::readPassword(confirmedPassword);
+        util::read(confirmedPassword);
         if (confirmedPassword != newPassword)
         {
             std::cout << "Passwords are different. Try again\n";

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

@@ -27,11 +27,8 @@ void UserInterface::run()
 {
 	try
 	{
-		if (!m_controller.initialize())
+		m_controller.loadSystemData();
-		{
+		m_controller.runSystemChecks();
-			std::cout << "Error: Failed to initialize the system!";
-			return;
-		}
 		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)
 	{
@@ -109,7 +106,7 @@ void UserInterface::login()
 	std::cout << "Enter username: ";
 	util::read(username);
 	std::cout << "Enter password: ";
-	util::readPassword(password);
+	util::read(password);
 	if (m_controller.login(username, password))
 	{
 		const User* authenticatedUser = m_controller.getAuthenticatedUser();
@@ -170,7 +167,7 @@ void UserInterface::registerCustomer()
 		return;
 	}
 	std::cout << "Enter password: ";
-	util::readPassword(password);
+	util::read(password);
 	if (!util::isPasswordValid(password))
 	{
 		std::cout << "Error: Password is invalid!";