Implement Model Refactoring

<UserStory> 1955: Model Refactoring</UserStory>

UserStory #1955

<Changes>
1. Replaced CSV-based serialization and deserialization in ComboPackage, JobCard, Service, and ServiceBooking models with fixed-size SerializedRecord structures for shared memory storage.
2. Implemented serialize() methods to convert objects into SerializedComboPackage, SerializedJobCard, SerializedService, and SerializedServiceBooking records.
3. Implemented deserialize() methods to reconstruct objects directly from SerializedRecord types instead of parsing CSV strings.
4. Updated model class interfaces to use SerializedRecord types, removing legacy CSV serialization APIs and header generation functions.
5. Added SerializedRecords.h dependencies and forward declarations for Serialized structures across affected models.
</Changes>

<Test>
N/A
</Test>

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

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

@@ -102,7 +102,7 @@
       <SDLCheck>true</SDLCheck>
       <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
-      <AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)factories;$(ProjectDir)views;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)core\patterns;$(ProjectDir)datastores;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)factories;$(ProjectDir)views;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)core\patterns;$(ProjectDir)datastores;$(ProjectDir)datastores\sharedmemory;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -117,7 +117,7 @@
       <SDLCheck>true</SDLCheck>
       <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
-      <AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)factories;$(ProjectDir)views;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)core\patterns;$(ProjectDir)datastores;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)factories;$(ProjectDir)views;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)core\patterns;$(ProjectDir)datastores;$(ProjectDir)datastores\sharedmemory;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -129,6 +129,7 @@
     <ClCompile Include="core\patterns\Observer.cpp" />
     <ClCompile Include="core\patterns\Subject.cpp" />
     <ClCompile Include="datastores\DataStore.cpp" />
+    <ClCompile Include="datastores\sharedmemory\SharedMemory.cpp" />
     <ClCompile Include="models\ComboPackage.cpp" />
     <ClCompile Include="models\InventoryItem.cpp" />
     <ClCompile Include="models\Invoice.cpp" />
@@ -156,6 +157,12 @@
     <ClInclude Include="core\patterns\Observer.h" />
     <ClInclude Include="core\patterns\Subject.h" />
     <ClInclude Include="datastores\DataStore.h" />
+    <ClInclude Include="datastores\sharedmemory\FileHeader.h" />
+    <ClInclude Include="datastores\sharedmemory\MappingInfo.h" />
+    <ClInclude Include="datastores\sharedmemory\RecordState.h" />
+    <ClInclude Include="datastores\sharedmemory\SerializedRecords.h" />
+    <ClInclude Include="datastores\sharedmemory\SharedMemory.h" />
+    <ClInclude Include="datastores\sharedmemory\TrackedRecord.h" />
     <ClInclude Include="factories\Factory.h" />
     <ClInclude Include="models\ComboPackage.h" />
     <ClInclude Include="models\InventoryItem.h" />

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

@@ -64,6 +64,12 @@
     <Filter Include="Source Files\Core\Patterns">
       <UniqueIdentifier>{8057b93d-51a9-42df-b06e-01ce395f6308}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Header Files\DataStores\SharedMemory">
+      <UniqueIdentifier>{ec639004-44c6-4bd6-9963-077adde82b5f}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\DataStores\SharedMemory">
+      <UniqueIdentifier>{7aa8722e-adfa-466e-8211-de63f3b7892b}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Trenser.VehicleServiceSystem.cpp">
@@ -141,6 +147,9 @@
     <ClCompile Include="models\ComboPackage.cpp">
       <Filter>Source Files\Models</Filter>
     </ClCompile>
+    <ClCompile Include="datastores\sharedmemory\SharedMemory.cpp">
+      <Filter>Source Files\DataStores\SharedMemory</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="utilities\InputHelper.h">
@@ -251,5 +260,23 @@
     <ClInclude Include="views\MenuHelper.h">
       <Filter>Header Files\Views</Filter>
     </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\FileHeader.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\MappingInfo.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\RecordState.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\TrackedRecord.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\SerializedRecords.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
+    <ClInclude Include="datastores\sharedmemory\SharedMemory.h">
+      <Filter>Header Files\DataStores\SharedMemory</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

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

@@ -6,6 +6,7 @@ Description: Implementation file containing the method definitions of the
 Author: Trenser
 Date:19-May-2026
 */
+
 #include "ComboPackage.h"
 #include "Controller.h"
 #include "Enums.h"
@@ -392,9 +393,9 @@ Parameters:
 Returns:
     - void
 */
-void Controller::completeJob(const std::string& jobID)
+void Controller::updateJobStatus(const std::string& jobID)
 {
-    m_serviceManagementService.completeJob(jobID);
+    m_serviceManagementService.updateJobStatus(jobID);
 }
 
 /*
@@ -462,6 +463,38 @@ util::Map<std::string, const Invoice*> Controller::getInvoicesByUser()
     return userInvoicesReadOnly;
 }
 
+/*
+Function: getAllInvoices
+Description: Retrieves all invoices from the PaymentManagementService and returns them as a read-only map.
+Parameters:
+    - none
+Returns:
+    - util::Map<std::string, const Invoice*>: Map of invoice IDs to invoice objects
+*/
+util::Map<std::string, const Invoice*> Controller::getAllInvoices()
+{
+    auto invoices = m_paymentManagementService.getAllInvoices();
+    util::Map<std::string, const Invoice*> readOnlyInvoice;
+    for (int iterator = 0; iterator < invoices.getSize(); iterator++)
+    {
+        readOnlyInvoice.insert(invoices.getKeyAt(iterator), invoices.getValueAt(iterator));
+    }
+    return readOnlyInvoice;
+}
+
+/*
+Function: confirmPayment
+Description: Delegates payment confirmation for a given invoice ID to the PaymentManagementService.
+Parameters:
+    - invoiceID: std::string, ID of the invoice to confirm
+Returns:
+    - void
+*/
+void Controller::confirmPayment(const std::string& invoiceID)
+{
+    m_paymentManagementService.confirmPayment(invoiceID);
+}
+
 /*
 Function: completePayment
 Description: Completes payment for a specific invoice using the given payment mode.

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

@@ -59,11 +59,13 @@ public:
     void createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost);
     void removeService(const std::string& serviceID);
     util::Map<std::string, const JobCard*> getJobCardsByUser();
-    void completeJob(const std::string& jobID);
+    void updateJobStatus(const std::string& jobID);
     void removeUser(const std::string& userID);
     void createComboPackage(const std::string& name, const util::Vector<std::string>& serviceIDs, double discountPercentage);
     void removeComboPackage(const std::string& comboPackageID);
     util::Map<std::string, const Invoice*> getInvoicesByUser();
+    util::Map<std::string, const Invoice*> getAllInvoices();
+    void confirmPayment(const std::string& invoiceID);
     void completePayment(const std::string& invoiceID, util::PaymentMode paymentMode);
     util::Vector<const Notification*> getNotifications();
     void deleteNotification(const std::string& notificationID);

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

@@ -9,6 +9,167 @@ Date: 19-May-2026
 */
 
 #include "DataStore.h"
+#include "Config.h"
+#include "SerializedRecords.h"
+#include "FileHelper.h"
+
+DataStore::DataStore() :
+    m_globalMutex(NULL) {}
+
+/*
+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
@@ -26,104 +187,370 @@ DataStore& DataStore::getInstance()
 
 /*
 Function: getUsers
-Description: Retrieves the internal map of users.
+Description: Retrieves all user records from the datastore.
 Parameters:
     - None
 Returns:
-    - Reference to util::Map<std::string, User*> containing all users.
+    - util::Map<std::string, TrackedRecord<User>>: Collection of user records
 */
-util::Map<std::string, User*>& DataStore::getUsers()
+util::Map<std::string, TrackedRecord<User>> DataStore::getUsers()
 {
-    return m_users;
+    return util::Map<std::string, TrackedRecord<User>>();
+}
+
+/*
+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()
+{
+    return util::Map<std::string, TrackedRecord<Notification>>();
 }
 
 /*
 Function: getServices
-Description: Retrieves the internal map of services.
+Description: Retrieves all service records from the datastore.
 Parameters:
     - None
 Returns:
-    - Reference to util::Map<std::string, Service*> containing all services.
+    - util::Map<std::string, TrackedRecord<Service>>: Collection of service records
 */
-util::Map<std::string, Service*>& DataStore::getServices()
+util::Map<std::string, TrackedRecord<Service>> DataStore::getServices()
 {
-    return m_services;
+    return util::Map<std::string, TrackedRecord<Service>>();
 }
 
 /*
 Function: getComboPackages
-Description: Retrieves the internal map of combo packages.
+Description: Retrieves all combo package records from the datastore.
 Parameters:
     - None
 Returns:
-    - Reference to util::Map<std::string, ComboPackage*> containing all combo packages.
+    - util::Map<std::string, TrackedRecord<ComboPackage>>: Collection of combo package records
 */
-util::Map<std::string, ComboPackage*>& DataStore::getComboPackages()
+util::Map<std::string, TrackedRecord<ComboPackage>> DataStore::getComboPackages()
 {
-    return m_comboPackages;
+    return util::Map<std::string, TrackedRecord<ComboPackage>>();
-}
-
-/*
-Function: getServiceBookings
-Description: Retrieves the internal map of service bookings.
-Parameters:
-    - None
-Returns:
-    - Reference to util::Map<std::string, ServiceBooking*> containing all service bookings.
-*/
-util::Map<std::string, ServiceBooking*>& DataStore::getServiceBookings()
-{
-    return m_serviceBookings;
-}
-
-/*
-Function: getJobCards
-Description: Retrieves the internal map of job cards.
-Parameters:
-    - None
-Returns:
-    - Reference to util::Map<std::string, JobCard*> containing all job cards.
-*/
-util::Map<std::string, JobCard*>& DataStore::getJobCards()
-{
-    return m_jobCards;
 }
 
 /*
 Function: getInventoryItems
-Description: Retrieves the internal map of inventory items.
+Description: Retrieves all inventory item records from the datastore.
 Parameters:
     - None
 Returns:
-    - Reference to util::Map<std::string, InventoryItem*> containing all inventory items.
+    - util::Map<std::string, TrackedRecord<InventoryItem>>: Collection of inventory item records
 */
-util::Map<std::string, InventoryItem*>& DataStore::getInventoryItems()
+util::Map<std::string, TrackedRecord<InventoryItem>> DataStore::getInventoryItems()
 {
-    return m_inventoryItems;
+    return util::Map<std::string, TrackedRecord<InventoryItem>>();
+}
+
+/*
+Function: getServiceBookings
+Description: Retrieves all service booking records from the datastore.
+Parameters:
+    - None
+Returns:
+    - util::Map<std::string, TrackedRecord<ServiceBooking>>: Collection of service booking records
+*/
+util::Map<std::string, TrackedRecord<ServiceBooking>> DataStore::getServiceBookings()
+{
+    return util::Map<std::string, TrackedRecord<ServiceBooking>>();
+}
+
+/*
+Function: getJobCards
+Description: Retrieves all job card records from the datastore.
+Parameters:
+    - None
+Returns:
+    - util::Map<std::string, TrackedRecord<JobCard>>: Collection of job card records
+*/
+util::Map<std::string, TrackedRecord<JobCard>> DataStore::getJobCards()
+{
+    return util::Map<std::string, TrackedRecord<JobCard>>();
 }
 
 /*
 Function: getInvoices
-Description: Retrieves the internal map of invoices.
+Description: Retrieves all invoice records from the datastore.
 Parameters:
     - None
 Returns:
-    - Reference to util::Map<std::string, Invoice*> containing all invoices.
+    - util::Map<std::string, TrackedRecord<Invoice>>: Collection of invoice records
 */
-util::Map<std::string, Invoice*>& DataStore::getInvoices()
+util::Map<std::string, TrackedRecord<Invoice>> DataStore::getInvoices()
 {
-    return m_invoices;
+    return util::Map<std::string, TrackedRecord<Invoice>>();
 }
 
 /*
 Function: getPayments
-Description: Retrieves the internal map of payments.
+Description: Retrieves all payment records from the datastore.
 Parameters:
     - None
 Returns:
-    - Reference to util::Map<std::string, Payment*> containing all payments.
+    - util::Map<std::string, TrackedRecord<Payment>>: Collection of payment records
 */
-util::Map<std::string, Payment*>& DataStore::getPayments()
+util::Map<std::string, TrackedRecord<Payment>> DataStore::getPayments()
 {
-    return m_payments;
+    return util::Map<std::string, TrackedRecord<Payment>>();
+}
+
+/*
+Function: getServiceManagementObservers
+Description: Retrieves all service management observer records from the datastore.
+Parameters:
+    - None
+Returns:
+    - util::Map<std::string, TrackedRecord<std::string>>: Collection of observer records
+*/
+util::Map<std::string, TrackedRecord<std::string>> DataStore::getServiceManagementObservers()
+{
+    return util::Map<std::string, TrackedRecord<std::string>>();
+}
+
+/*
+Function: getPaymentManagementObservers
+Description: Retrieves all payment management observer records from the datastore.
+Parameters:
+    - None
+Returns:
+    - util::Map<std::string, TrackedRecord<std::string>>: Collection of observer records
+*/
+util::Map<std::string, TrackedRecord<std::string>> DataStore::getPaymentManagementObservers()
+{
+    return util::Map<std::string, TrackedRecord<std::string>>();
+}
+
+/*
+Function: getInventoryManagementObservers
+Description: Retrieves all inventory management observer records from the datastore.
+Parameters:
+    - None
+Returns:
+    - util::Map<std::string, TrackedRecord<std::string>>: Collection of observer records
+*/
+util::Map<std::string, TrackedRecord<std::string>> DataStore::getInventoryManagementObservers()
+{
+    return util::Map<std::string, TrackedRecord<std::string>>();
+}
+
+/*
+Function: saveUsers
+Description: Persists all user records to the datastore.
+Parameters:
+    - users: util::Map<std::string, TrackedRecord<User>>&, collection of user records
+Returns:
+    - None
+*/
+void DataStore::saveUsers(util::Map<std::string, TrackedRecord<User>>& users)
+{
+}
+
+/*
+Function: saveNotifications
+Description: Persists all notification records to the datastore.
+Parameters:
+    - notifications: util::Map<std::string, TrackedRecord<Notification>>&, collection of notification records
+Returns:
+    - None
+*/
+void DataStore::saveNotifications(util::Map<std::string, TrackedRecord<Notification>>& notifications)
+{
+}
+
+/*
+Function: saveServices
+Description: Persists all service records to the datastore.
+Parameters:
+    - services: util::Map<std::string, TrackedRecord<Service>>&, collection of service records
+Returns:
+    - None
+*/
+void DataStore::saveServices(util::Map<std::string, TrackedRecord<Service>>& services)
+{
+}
+
+/*
+Function: saveComboPackages
+Description: Persists all combo package records to the datastore.
+Parameters:
+    - comboPackages: util::Map<std::string, TrackedRecord<ComboPackage>>&, collection of combo package records
+Returns:
+    - None
+*/
+void DataStore::saveComboPackages(util::Map<std::string, TrackedRecord<ComboPackage>>& comboPackages)
+{
+}
+
+/*
+Function: saveInventoryItems
+Description: Persists all inventory item records to the datastore.
+Parameters:
+    - inventoryItems: util::Map<std::string, TrackedRecord<InventoryItem>>&, collection of inventory item records
+Returns:
+    - None
+*/
+void DataStore::saveInventoryItems(util::Map<std::string, TrackedRecord<InventoryItem>>& inventoryItems)
+{
+}
+
+/*
+Function: saveServiceBookings
+Description: Persists all service booking records to the datastore.
+Parameters:
+    - bookings: util::Map<std::string, TrackedRecord<ServiceBooking>>&, collection of service booking records
+Returns:
+    - None
+*/
+void DataStore::saveServiceBookings(util::Map<std::string, TrackedRecord<ServiceBooking>>& bookings)
+{
+}
+
+/*
+Function: saveJobCards
+Description: Persists all job card records to the datastore.
+Parameters:
+    - jobCards: util::Map<std::string, TrackedRecord<JobCard>>&, collection of job card records
+Returns:
+    - None
+*/
+void DataStore::saveJobCards(util::Map<std::string, TrackedRecord<JobCard>>& jobCards)
+{
+}
+
+/*
+Function: saveInvoices
+Description: Persists all invoice records to the datastore.
+Parameters:
+    - invoices: util::Map<std::string, TrackedRecord<Invoice>>&, collection of invoice records
+Returns:
+    - None
+*/
+void DataStore::saveInvoices(util::Map<std::string, TrackedRecord<Invoice>>& invoices)
+{
+}
+
+/*
+Function: savePayments
+Description: Persists all payment records to the datastore.
+Parameters:
+    - payments: util::Map<std::string, TrackedRecord<Payment>>&, collection of payment records
+Returns:
+    - None
+*/
+void DataStore::savePayments(util::Map<std::string, TrackedRecord<Payment>>& payments)
+{
+}
+
+/*
+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, TrackedRecord<std::string>>& observers)
+{
+}
+
+/*
+Function: savePaymentManagementObservers
+Description: Persists all payment management observer records to the datastore.
+Parameters:
+    - observers: util::Map<std::string, TrackedRecord<std::string>>&, collection of observer records
+Returns:
+    - None
+*/
+void DataStore::savePaymentManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers)
+{
+}
+
+/*
+Function: saveInventoryManagementObservers
+Description: Persists all inventory management observer records to the datastore.
+Parameters:
+    - observers: util::Map<std::string, TrackedRecord<std::string>>&, collection of observer records
+Returns:
+    - None
+*/
+void DataStore::saveInventoryManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& 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

@@ -6,42 +6,166 @@ Date: 19-May-2026
 */
 
 #pragma once
+#include <windows.h>
 #include <string>
 #include "Map.h"
-
+#include "MappingInfo.h"
+#include "TrackedRecord.h"
+#include "SharedMemory.h"
 class User;
+class Notification;
 class Service;
 class ComboPackage;
+class InventoryItem;
 class ServiceBooking;
 class JobCard;
-class InventoryItem;
 class Invoice;
 class Payment;
 
 class DataStore
 {
 private:
-    util::Map<std::string, User*> m_users;
+    DataStore();
-    util::Map<std::string, Service*> m_services;
-    util::Map<std::string, ComboPackage*> m_comboPackages;
-    util::Map<std::string, ServiceBooking*> m_serviceBookings;
-    util::Map<std::string, JobCard*> m_jobCards;
-    util::Map<std::string, InventoryItem*> m_inventoryItems;
-    util::Map<std::string, Invoice*> m_invoices;
-    util::Map<std::string, Payment*> m_payments;
-    DataStore() {}
-public:
-    static DataStore& getInstance();
     DataStore(const DataStore&) = delete;
     DataStore& operator=(const DataStore&) = delete;
     DataStore(DataStore&&) = delete;
     DataStore& operator=(DataStore&&) = delete;
-    util::Map<std::string, User*>& getUsers();
+    HANDLE m_globalMutex;
-    util::Map<std::string, Service*>& getServices();
+    MappingInfo m_users;
-    util::Map<std::string, ComboPackage*>& getComboPackages();
+    MappingInfo m_notifications;
-    util::Map<std::string, ServiceBooking*>& getServiceBookings();
+    MappingInfo m_services;
-    util::Map<std::string, JobCard*>& getJobCards();
+    MappingInfo m_comboPackages;
-    util::Map<std::string, InventoryItem*>& getInventoryItems();
+    MappingInfo m_inventoryItems;
-    util::Map<std::string, Invoice*>& getInvoices();
+    MappingInfo m_serviceBookings;
-    util::Map<std::string, Payment*>& getPayments();
+    MappingInfo m_jobCards;
+    MappingInfo m_invoices;
+    MappingInfo m_payments;
+    MappingInfo m_serviceManagementObservers;
+    MappingInfo m_paymentManagementObservers;
+    MappingInfo m_inventoryManagementObservers;
+public:
+    static DataStore& getInstance();
+    bool initialize();
+    void shutdown();
+    util::Map<std::string, TrackedRecord<User>> getUsers();
+    util::Map<std::string, TrackedRecord<Notification>> getNotifications();
+    util::Map<std::string, TrackedRecord<Service>> getServices();
+    util::Map<std::string, TrackedRecord<ComboPackage>> getComboPackages();
+    util::Map<std::string, TrackedRecord<InventoryItem>> getInventoryItems();
+    util::Map<std::string, TrackedRecord<ServiceBooking>> getServiceBookings();
+    util::Map<std::string, TrackedRecord<JobCard>> getJobCards();
+    util::Map<std::string, TrackedRecord<Invoice>> getInvoices();
+    util::Map<std::string, TrackedRecord<Payment>> getPayments();
+    util::Map<std::string, TrackedRecord<std::string>> getServiceManagementObservers();
+    util::Map<std::string, TrackedRecord<std::string>> getPaymentManagementObservers();
+    util::Map<std::string, TrackedRecord<std::string>> getInventoryManagementObservers();
+    void saveUsers(util::Map<std::string, TrackedRecord<User>>& users);
+    void saveNotifications(util::Map<std::string, TrackedRecord<Notification>>& notifications);
+    void saveServices(util::Map<std::string, TrackedRecord<Service>>& services);
+    void saveComboPackages(util::Map<std::string, TrackedRecord<ComboPackage>>& comboPackages);
+    void saveInventoryItems(util::Map<std::string, TrackedRecord<InventoryItem>>& inventoryItems);
+    void saveServiceBookings(util::Map<std::string, TrackedRecord<ServiceBooking>>& bookings);
+    void saveJobCards(util::Map<std::string, TrackedRecord<JobCard>>& jobCards);
+    void saveInvoices(util::Map<std::string, TrackedRecord<Invoice>>& invoices);
+    void savePayments(util::Map<std::string, TrackedRecord<Payment>>& payments);
+    void saveServiceManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers);
+    void savePaymentManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers);
+    void saveInventoryManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers);
+    bool lockDataStore();
+    bool unlockDataStore();
+private:
+    template<typename TObject, typename TSerialized>
+    util::Map<std::string, TrackedRecord<TObject>> loadRecords(MappingInfo& mapping);
+    template<typename TObject, typename TSerialized>
+    void saveRecords(MappingInfo& mapping, util::Map<std::string, TrackedRecord<TObject>>& records);
 };
+
+/*
+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. After persistence, all
+             temporary objects owned by the tracked records are
+             destroyed to release memory.
+Parameter:
+    - mapping: Reference to the mapping where records are
+               stored.
+    - 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);
+        }
+    }
+    for (int index = 0; index < records.getSize(); ++index)
+    {
+        delete records.getValueAt(index).data;
+        records.getValueAt(index).data = nullptr;
+    }
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,385 @@
+/*
+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 "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

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

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

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

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

@@ -9,6 +9,7 @@ Date: 19-May-2026
 
 #include <sstream>
 #include <stdexcept>
+#include "SerializedRecords.h"
 #include "ComboPackage.h"
 #include "Service.h"
 #include "Factory.h"
@@ -28,7 +29,8 @@ Returns:
 ComboPackage::ComboPackage()
     : m_id("CMP" + std::to_string(++m_uid)),
     m_status(util::State::ACTIVE),
-    m_discountPercentage(0.0) {}
+    m_discountPercentage(0.0) {
+}
 
 /*
 Function: ComboPackage
@@ -270,72 +272,38 @@ static util::Vector<std::string> getServiceIDsAsVector(const std::string& servic
 
 /*
 Function: serialize
-Description: Serializes the combo package into a CSV-formatted string.
+Description: Serializes the ComboPackage object into a SerializedComboPackage record.
 Parameters:
     - None
 Returns:
-    - std::string: Serialized combo package record
+    - SerializedComboPackage: Serialized representation of the combo package
 */
-std::string ComboPackage::serialize() const
+SerializedComboPackage ComboPackage::serialize() const
 {
-    std::ostringstream serializedComboPackage;
+    SerializedComboPackage 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/JobCard.cpp

@@ -9,6 +9,7 @@ Date:19-May-2026
 
 #include <sstream>
 #include <stdexcept>
+#include "SerializedRecords.h"
 #include "JobCard.h"
 #include "Factory.h"
 #include "StringHelper.h"
@@ -28,7 +29,8 @@ JobCard::JobCard()
     m_booking(nullptr),
     m_service(nullptr),
     m_technician(nullptr),
-    m_status(util::ServiceJobStatus()) {}
+    m_status(util::ServiceJobStatus()) {
+}
 
 /*
 Function: JobCard
@@ -65,7 +67,8 @@ JobCard::JobCard(const std::string& bookingId,
     m_technician(technician),
     m_assignedDate(assignedDate),
     m_status(status),
-    m_completionDate(completionDate) {}
+    m_completionDate(completionDate) {
+}
 
 /*
 Function: JobCard (parameterized constructor with ID)
@@ -351,79 +354,41 @@ void JobCard::setCompletionDate(const util::Timestamp& completionDate)
 
 /*
 Function: serialize
-Description: Serializes the job card into a CSV-formatted string.
+Description: Serializes the JobCard object into a SerializedJobCard record.
 Parameters:
     - None
 Returns:
-    - std::string: Serialized job card record
+    - SerializedJobCard: Serialized representation of the job card
 */
-std::string JobCard::serialize() const
+SerializedJobCard JobCard::serialize() const
 {
-    std::ostringstream serializedJobCard;
+    SerializedJobCard 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/Service.cpp

@@ -8,6 +8,7 @@ Date: 19-May-2026
 */
 
 #include <sstream>
+#include "SerializedRecords.h"
 #include "Service.h"
 #include "InventoryItem.h"
 #include "StringHelper.h"
@@ -27,7 +28,8 @@ Returns:
 Service::Service()
     : m_id("SRV" + std::to_string(++m_uid)),
     m_status(util::State::ACTIVE),
-    m_laborCost(0.0) {}
+    m_laborCost(0.0) {
+}
 
 /*
 Function: Service
@@ -266,72 +268,38 @@ static util::Vector<std::string> getInventoryItemIDsAsVector(const std::string&
 
 /*
 Function: serialize
-Description: Serializes the service into a CSV-formatted string.
+Description: Serializes the Service object into a SerializedService record.
 Parameters:
     - None
 Returns:
-    - std::string: Serialized service record
+    - SerializedService: Serialized representation of the service
 */
-std::string Service::serialize() const
+SerializedService Service::serialize() const
 {
-    std::ostringstream serializedService;
+    SerializedService 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

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

@@ -6,8 +6,10 @@ Description: Implementation file containing the method definitions of the
 Author: Trenser
 Date:19-May-2026
 */
+
 #include <stdexcept>
 #include <sstream>
+#include "SerializedRecords.h"
 #include "ServiceBooking.h"
 #include "Service.h"
 #include "Enums.h"
@@ -28,7 +30,8 @@ ServiceBooking::ServiceBooking()
     m_customer(nullptr),
     m_assignedTechnician(nullptr),
     m_status(util::ServiceJobStatus::PENDING),
-    m_discountPercentage(0.0) {}
+    m_discountPercentage(0.0) {
+}
 
 /*
 Function: ServiceBooking
@@ -437,84 +440,46 @@ static util::Vector<std::string> getServiceIDsAsVector(const std::string& servic
 
 /*
 Function: serialize
-Description: Serializes the service booking into a CSV-formatted string.
+Description: Serializes the ServiceBooking object into a SerializedServiceBooking record.
 Parameters:
     - None
 Returns:
-    - std::string: Serialized booking record
+    - SerializedServiceBooking: Serialized representation of the service booking
 */
-std::string ServiceBooking::serialize() const
+SerializedServiceBooking ServiceBooking::serialize() const
 {
-    std::ostringstream serializedBooking;
+    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

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

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

@@ -368,12 +368,12 @@ void PaymentManagementService::completePayment(const std::string& invoiceID, uti
 	if (invoiceIndex != -1)
 	{
 		Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
-		if (invoice && invoice->getStatus() != util::PaymentStatus::COMPLETED)
+		if (invoice && invoice->getStatus() != util::PaymentStatus::PAID)
 		{
 			User* currentUser = invoice->getBooking()->getCustomer();
 			invoice->setPaymentMethod(paymentMode);
 			invoice->setPaymentDate(util::Timestamp());
-			invoice->setStatus(util::PaymentStatus::COMPLETED);
+			invoice->setStatus(util::PaymentStatus::PAID);
 			std::string title, message;
 			title = "Payment successful";
 			message = "Payment successful for Invoice ID " + invoiceID;
@@ -385,3 +385,47 @@ void PaymentManagementService::completePayment(const std::string& invoiceID, uti
 		throw std::runtime_error("Payment failed: invalid invoice ID.");
 	}
 }
+
+/*
+Function: getAllInvoice
+Description: Provides access to all invoices stored in the data store.
+Parameters:
+	- none
+Returns:
+	- util::Map<std::string, Invoice*>&: Map of invoice IDs to invoice objects
+*/
+util::Map<std::string, Invoice*>& PaymentManagementService::getAllInvoices()
+{
+	return m_dataStore.getInvoices();
+}
+
+/*
+Function: confirmPayment
+Description: Confirms payment for a specific invoice. Updates payment date and status,
+			 then sends a notification to the customer.
+Parameters:
+	- invoiceID: std::string, ID of the invoice to confirm
+Returns:
+	- void
+Throws:
+	- std::runtime_error if the invoice ID is invalid
+*/
+void PaymentManagementService::confirmPayment(const std::string& invoiceID)
+{
+	auto& currentInvoices = m_dataStore.getInvoices();
+	int invoiceIndex = currentInvoices.find(invoiceID);
+	if (invoiceIndex == -1)
+	{
+		throw std::runtime_error("Payment confirmation failed: invalid invoice ID.");
+	}
+	Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
+	if (!invoice || invoice->getStatus() != util::PaymentStatus::PAID)
+	{
+		throw std::runtime_error("Payment confirmation failed: invoice is not awaiting confirmation.");
+	}
+	User* currentUser = invoice->getBooking()->getCustomer();
+	invoice->setStatus(util::PaymentStatus::COMPLETED);
+	std::string title = "Payment Confirmed";
+	std::string message = "Payment Confirmed for Invoice ID " + invoiceID;
+	sendNotification(currentUser, title, message);
+}

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

@@ -28,6 +28,8 @@ public:
     void generateInvoice(ServiceBooking* booking);
     util::Map<std::string, Invoice*> getInvoices(const std::string& customerID);
     void completePayment(const std::string& invoiceID, util::PaymentMode paymentMode);
+    util::Map<std::string, Invoice*>& getAllInvoices();
+    void confirmPayment(const std::string& invoiceID);
     void sendPaymentReminders();
     void sendNotification(User* user, const std::string& title, const std::string& message) override;
     void attach(User* user) override;

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

@@ -543,50 +543,65 @@ static void restoreInventory(ServiceBooking* booking)
 
 /*
 Function: processBookingCancellation
-Description: Cancels jobs and updates the status of a given booking. Sends notifications to the
+Description: Handles cancellation or reassignment of a service booking based on user type.
-             specified user, resets technician assignment if needed, and restores inventory items.
+             Cancels associated job cards, updates booking status, clears technician assignments,
-Parameter: ServiceBooking* booking - Pointer to the booking being cancelled
+             restores inventory, and sends appropriate notifications.
-           util::ServiceJobStatus newServiceBookingStatus - New status to assign to the booking
+Parameters:
-           const std::string& notificationTitle - Title of the booking cancellation notification
+    ServiceBooking* booking - The booking to cancel or reset
-           const std::string& notificationMessage - Message body of the booking cancellation notification
-           User* notifyUser - User to notify about the cancellation
-           util::ServiceJobStatus jobCardStatus - New status to assign to associated job cards
-           const std::string& jobNotificationTitle - Title of the job cancellation notification
-           const std::string& jobNotificationMessage - Message body of the job cancellation notification
     util::Map<std::string, JobCard*>& jobs - Collection of job cards to update
-           ServiceManagementService& currentService - Reference to the service for sending notifications
+    ServiceManagementService& currentService - Service layer for notifications
+    util::UserType userType - Type of user initiating cancellation (CUSTOMER or TECHNICIAN)
 Return type: void
 */
 static void processBookingCancellation(ServiceBooking* booking,
-    util::ServiceJobStatus newServiceBookingStatus,
+    util::Map<std::string, JobCard*>& jobs,
-    const std::string& notificationTitle,
+    ServiceManagementService& currentService,
-    const std::string& notificationMessage,
+    util::UserType userType)
-    User* notifyUser,
-    util::ServiceJobStatus jobCardStatus,
-    const std::string& jobNotificationTitle,
-    const std::string& jobNotificationMessage,
-    util::Map<std::string, JobCard*>& jobs, ServiceManagementService& currentService)
 {
-    if (!booking || !notifyUser)
+    if (!booking)
     {
         return;
     }
     for (int jobIterator = 0; jobIterator < jobs.getSize(); ++jobIterator)
     {
         JobCard* jobCard = jobs.getValueAt(jobIterator);
-        if (jobCard && jobCard->getBookingId() == booking->getId())
+        if (!jobCard || jobCard->getBookingId() != booking->getId() || jobCard->getStatus() == util::ServiceJobStatus::CANCELLED)
         {
-            jobCard->setStatus(jobCardStatus);
+            continue;
-            currentService.sendNotification(notifyUser, jobNotificationTitle, jobNotificationMessage);
+        }
+        jobCard->setStatus(util::ServiceJobStatus::CANCELLED);
+        if (userType == util::UserType::CUSTOMER)
+        {
+            if (User* technician = booking->getAssignedTechnician())
+            {
+                const std::string jobTitle = "Job Cancelled";
+                const std::string jobMessage = "Your job card has been cancelled and the inventory has been restocked.";
+                currentService.sendNotification(technician, jobTitle, jobMessage);
             }
         }
-    booking->setStatus(newServiceBookingStatus);
+    }
-    currentService.sendNotification(notifyUser, notificationTitle, notificationMessage);
+    if (userType == util::UserType::CUSTOMER)
-    if (newServiceBookingStatus == util::ServiceJobStatus::PENDING)
     {
+        booking->setStatus(util::ServiceJobStatus::CANCELLED);
+        if (User* technician = booking->getAssignedTechnician())
+        {
+            const std::string title = "Customer Service Cancelled";
+            const std::string message = "Your assigned job card has been cancelled and the inventory has been restocked.";
+            currentService.sendNotification(technician, title, message);
+        }
+    }
+    else if (userType == util::UserType::TECHNICIAN)
+    {
+        booking->setStatus(util::ServiceJobStatus::PENDING);
+        if (User* customer = booking->getCustomer())
+        {
+            const std::string title = "Technician Unavailable";
+            const std::string message = "Your booking has been reset to pending and we will reassign a new technician shortly.";               
+            currentService.sendNotification(customer, title, message);
+        }
+    }
     booking->setAssignedTechnician(nullptr);
     booking->setAssignedTechnicianId("");
-    }
     restoreInventory(booking);
 }
 
@@ -624,21 +639,13 @@ void ServiceManagementService::cancelCustomerServiceBookings(const std::string&
         {
             continue;
         }
-        if (booking->getStatus() != util::ServiceJobStatus::PENDING && booking->getStatus() != util::ServiceJobStatus::STARTED)
+        if (booking->getStatus() != util::ServiceJobStatus::PENDING &&
+            booking->getStatus() != util::ServiceJobStatus::STARTED && 
+            booking->getStatus() != util::ServiceJobStatus::IN_PROGRESS)
         {
             continue;
         }
-        User* assignedTechnician = booking->getAssignedTechnician();
+        processBookingCancellation(booking, jobs, *this, util::UserType::CUSTOMER);
-        std::string titleToTechnician = "Customer Service Cancelled";
-        std::string messageToTechnician = "The customer has cancelled their service booking. Your assigned job card has been cancelled and the inventory has been restocked.";
-        std::string jobTitle = "Job Cancelled";
-        std::string jobMessage = "The job has been cancelled. Your job card has been cancelled and the inventory has been restocked.";
-        processBookingCancellation(booking, 
-            util::ServiceJobStatus::CANCELLED,
-            titleToTechnician, messageToTechnician, assignedTechnician,
-            util::ServiceJobStatus::CANCELLED,
-            jobTitle, jobMessage, jobs, *this
-        );
     }
 }
 
@@ -676,7 +683,9 @@ void ServiceManagementService::cancelTechnicianJobs(const std::string& technicia
         {
             continue;
         }
-        if (booking->getStatus() != util::ServiceJobStatus::PENDING && booking->getStatus() != util::ServiceJobStatus::STARTED)
+        if (booking->getStatus() != util::ServiceJobStatus::PENDING &&
+            booking->getStatus() != util::ServiceJobStatus::STARTED &&
+            booking->getStatus() != util::ServiceJobStatus::IN_PROGRESS)
         {
             continue;
         }
@@ -685,14 +694,7 @@ void ServiceManagementService::cancelTechnicianJobs(const std::string& technicia
         {
             continue;
         }
-        std::string title = "Technician Unavailable";
+        processBookingCancellation(booking, jobs, *this, util::UserType::TECHNICIAN);
-        std::string message = "Your assigned technician is no longer available. Your booking has been reset to pending and we will reassign a new technician shortly.";
-        processBookingCancellation(booking,
-            util::ServiceJobStatus::PENDING,
-            title, message, customer,
-            util::ServiceJobStatus::CANCELLED,
-            title, message, jobs, *this
-        );
     }
 }
 
@@ -1080,7 +1082,7 @@ static bool hasCompletedAllJobs(std::string bookingId, util::Map<std::string, Jo
 		JobCard* currentJob = currentAssignedJobs.getValueAt(iterator);
 		if (currentJob->getBookingId() == bookingId)
 		{
-			if (currentJob->getStatus() == util::ServiceJobStatus::STARTED)
+			if (currentJob->getStatus() != util::ServiceJobStatus::COMPLETED && currentJob->getStatus() != util::ServiceJobStatus::CANCELLED)
 			{
 				return false;
 			}
@@ -1090,18 +1092,19 @@ static bool hasCompletedAllJobs(std::string bookingId, util::Map<std::string, Jo
 }
 
 /*
-Function: completeJob
+Function: updateJobStatus
-Description: Marks a job card as completed for the authenticated technician.
+Description:
-			 If all job cards in the booking are completed, marks the booking as completed
+    Updates the status of a job card assigned to the currently authenticated technician.
-			 and generates an invoice.
+    - If the job is STARTED, it moves to IN_PROGRESS.
+    - If the job is IN_PROGRESS, it moves to COMPLETED.
+    When all jobs in a service booking are completed, the booking status is updated,
+    an invoice is generated, and a notification is sent to the customer.
 Parameters:
-	- jobID: std::string, ID of the job card
+    - jobID: const std::string&, unique identifier of the job card to update.
 Returns:
     - void
-Throws:
-	- std::runtime_error if technician is not authenticated, job card not found, or job already completed
 */
-void ServiceManagementService::completeJob(const std::string& jobID)
+void ServiceManagementService::updateJobStatus(const std::string& jobID)
 {
 	AuthenticationManagementService authenticationManagementService;
 	PaymentManagementService paymentManagementService;
@@ -1126,19 +1129,13 @@ void ServiceManagementService::completeJob(const std::string& jobID)
 		}
 		if (currentJob->getStatus() == util::ServiceJobStatus::STARTED)
 		{
-			currentJob->setStatus(util::ServiceJobStatus::COMPLETED);
+			currentJob->setStatus(util::ServiceJobStatus::IN_PROGRESS);
 			jobStatusUpdated = true;
 		}
-	}
+        else if (currentJob->getStatus() == util::ServiceJobStatus::IN_PROGRESS)
-	else
         {
-		throw std::runtime_error("Failed to complete the job, some error occurred or job already completed.");
+            currentJob->setStatus(util::ServiceJobStatus::COMPLETED);
-	}
+            jobStatusUpdated = true;
-	if (!jobStatusUpdated)
-	{
-		throw std::runtime_error("Failed to complete the job, some error occurred or job already completed.");
-	}
-
             serviceBookingCompleted = hasCompletedAllJobs(currentJob->getBookingId(), currentAssignedJobs);
             if (serviceBookingCompleted)
             {
@@ -1148,4 +1145,14 @@ void ServiceManagementService::completeJob(const std::string& jobID)
                 std::string message = "Services completed for the booking and invoice generated.";
                 sendNotification(currentJob->getBooking()->getCustomer(), title, message);
             }
+        }
+	}
+	else
+	{
+		throw std::runtime_error("Failed to update job status. Job may already be completed.");
+	}
+	if (!jobStatusUpdated)
+	{
+		throw std::runtime_error("Failed to update job status. Job may already be completed.");
+	}
 }

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

@@ -37,7 +37,7 @@ public:
     void createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost);
     void removeService(const std::string& serviceID);
     util::Map<std::string, JobCard*> getJobCards(const std::string& technicianID);
-    void completeJob(const std::string& jobID);
+    void updateJobStatus(const std::string& jobID);
     void cancelCustomerServiceBookings(const std::string& customerID);
     void cancelTechnicianJobs(const std::string& technicianID);
     void createComboPackage(const std::string& packageName, const util::Vector<std::string>& serviceIDs, double discountPercentage);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -106,7 +106,7 @@ void UserInterface::login()
 	std::cout << "Enter username: ";
 	util::read(username);
 	std::cout << "Enter password: ";
-	util::read(password);
+	util::readPassword(password);
 	if (m_controller.login(username, password))
 	{
 		const User* authenticatedUser = m_controller.getAuthenticatedUser();
@@ -167,7 +167,7 @@ void UserInterface::registerCustomer()
 		return;
 	}
 	std::cout << "Enter password: ";
-	util::read(password);
+	util::readPassword(password);
 	if (!util::isPasswordValid(password))
 	{
 		std::cout << "Error: Password is invalid!";