Merged PR 1172: Payment Management Refactoring - 1930

User Story #1949
User Story #1950

**Changes**

* Added `DataStoreLockGuard` header to project configuration and implemented the class for scoped mutex management.
* Refactored `Invoice` model to replace CSV-based serialization with `SerializedInvoice` struct, removing legacy `getHeaders()` and string parsing logic.
* Updated `DataStore::getInvoices()` to load records via `loadRecords`, refresh cache, and automatically enrich `Invoice` objects with linked `ServiceBooking` and `InventoryItem` entities.
* Implemented `DataStore::saveInvoices()` using the `saveRecords<Invoice, SerializedInvoice>` template for direct shared memory persistence.
* Integrated `DataStoreLockGuard` across all critical methods in `PaymentManagementService`: `sendPaymentReminders`, `generateInvoice`, `getInvoices`, `completePayment`, `getAllInvoices`, and `confirmPayment`.
* Refactored invoice creation and modification flows to use `createNewRecord` for insertion and explicitly set `RecordState::MODIFIED` before triggering `saveInvoices()`.
* Updated data access patterns to extract `.data` pointers from `TrackedRecord` wrappers instead of accessing raw map values directly.
* Added validation logic in `getInvoices()` to throw `runtime_error` if referenced ServiceBookings or InventoryItems are missing.
* Added necessary header dependencies (`Invoice.h`, `DataStoreLockGuard.h`) in service and store layers.

Related work items: #1930, #1949, #1950

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

@@ -14,6 +14,7 @@ Date: 19-May-2026
 #include "FileHelper.h"
 #include "ServiceBooking.h"
 #include "JobCard.h"
+#include "Invoice.h"
 
 /*
 Function: DataStore
@@ -450,6 +451,45 @@ Returns:
 */
 util::Map<std::string, TrackedRecord<Invoice>>& DataStore::getInvoices()
 {
+    auto& serviceBookings = getServiceBookings();
+    auto& inventoryItems = getInventoryItems();
+    util::Map<std::string, TrackedRecord<Invoice>> invoices = loadRecords<Invoice, SerializedInvoice>(m_invoices);
+    refreshCache(m_invoiceCache, invoices);
+    for (int iterator = 0; iterator < m_invoiceCache.getSize(); iterator++)
+    {
+        auto& trackedInvoice = m_invoiceCache.getValueAt(iterator);
+        Invoice* invoice = trackedInvoice.data;
+        if (!invoice)
+        {
+            continue;
+        }
+        const std::string& currentBookingId = invoice->getBookingId();
+        int currentBookingIndex = serviceBookings.find(currentBookingId);
+        if (currentBookingIndex == -1)
+        {
+            throw std::runtime_error("Invalid Service Booking Index.");
+        }
+        ServiceBooking* currentBooking = serviceBookings.getValueAt(currentBookingIndex).data;
+        auto& currentInventoryItemIds = invoice->getPartIDs();
+        util::Map<std::string, InventoryItem*> currentInventoryItems;
+        for (int iterator = 0; iterator < currentInventoryItemIds.getSize(); iterator++)
+        {
+            const std::string& currentItemId = currentInventoryItemIds[iterator];
+            int currentItemIndex = inventoryItems.find(currentItemId);
+            if (currentItemIndex == -1)
+            {
+                throw std::runtime_error("Invalid Inventory item id.");
+            }
+            InventoryItem* currentItem = inventoryItems.getValueAt(currentItemIndex).data;
+            if (!currentItem)
+            {
+                continue;
+            }
+            currentInventoryItems[currentItemId] = currentItem;
+        }
+        invoice->setBooking(currentBooking);
+        invoice->setParts(currentInventoryItems);
+    }
     return m_invoiceCache;
 }
 
@@ -624,6 +664,7 @@ Returns:
 */
 void DataStore::saveInvoices()
 {
+    saveRecords<Invoice, SerializedInvoice>(m_invoices, m_invoiceCache);
 }
 
 /*
@@ -739,5 +780,4 @@ bool DataStore::unlockDataStore()
         return false;
     }
     return ReleaseMutex(m_globalMutex) != 0;
-}
-
+}

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

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

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

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

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

@@ -15,6 +15,7 @@ Date: 20-May-2026
 #include "Invoice.h"
 #include "JobCard.h"
 #include "PaymentManagementService.h"
+#include "DataStoreLockGuard.h"
 #include "Service.h"
 #include "ServiceBooking.h"
 #include "Timestamp.h"
@@ -121,11 +122,12 @@ Returns:
 */
 void PaymentManagementService::sendPaymentReminders()
 {
-	auto& invoicesMap = m_dataStore.getInvoices();
-	int invoicesMapSize = invoicesMap.getSize();
+	DataStoreLockGuard lock(m_dataStore);
+	auto& trackedInvoicesMap = m_dataStore.getInvoices();
+	int invoicesMapSize = trackedInvoicesMap.getSize();
 	for (int index = 0; index < invoicesMapSize; index++)
 	{
-		const Invoice* invoice = invoicesMap.getValueAt(index);
+		const Invoice* invoice = trackedInvoicesMap.getValueAt(index).data;
 		if (invoice && invoice->getStatus() == util::PaymentStatus::PENDING)
 		{
 			util::Timestamp invoiceCreationTimestamp = invoice->getInvoiceDate();
@@ -181,6 +183,7 @@ Throws:
 */
 void PaymentManagementService::generateInvoice(ServiceBooking* booking)
 {
+	DataStoreLockGuard lock(m_dataStore);
 	if (!booking)
 	{
 		throw std::runtime_error("Invoice generation failed: booking is null.");
@@ -190,10 +193,10 @@ void PaymentManagementService::generateInvoice(ServiceBooking* booking)
 	std::string bookingID = booking->getId();
 	util::Map<std::string, Service*> servicesInTheBookedService = booking->getServices();
 	util::Map<std::string, InventoryItem*> completeInventoryItemMapOfBooking;
-	util::Map<std::string, JobCard*> currentJobCards = m_dataStore.getJobCards();
-	for (int iterator = 0; iterator < currentJobCards.getSize(); iterator++)
+	auto& currentTrackedJobCards = m_dataStore.getJobCards();
+	for (int iterator = 0; iterator < currentTrackedJobCards.getSize(); iterator++)
 	{
-		JobCard* currentJobCard = currentJobCards.getValueAt(iterator);
+		JobCard* currentJobCard = currentTrackedJobCards.getValueAt(iterator).data;
 		util::ServiceJobStatus currentJobCardStatus = currentJobCard->getStatus();
 		if (currentJobCard->getBookingId() == bookingID && currentJobCardStatus != util::ServiceJobStatus::CANCELLED && currentJobCardStatus != util::ServiceJobStatus::COMPLETED)
 		{
@@ -213,8 +216,9 @@ void PaymentManagementService::generateInvoice(ServiceBooking* booking)
 	totalServiceCost = totalLaborCost + totalPartsCost;
 	totalServiceCost -= (totalServiceCost * (discountPercentage / 100));
 	Invoice* invoice = Factory::getObject<Invoice>(bookingID, booking, util::Timestamp(), totalLaborCost, completeInventoryItemMapOfBooking, totalPartsCost, discountPercentage, totalServiceCost, util::Timestamp(), util::PaymentMode::NOTSET, util::PaymentStatus::PENDING);
-	util::Map<std::string, Invoice*>& currentInvoices = m_dataStore.getInvoices();
-	currentInvoices.insert(invoice->getId(), invoice);
+	auto& currentTrackedInvoices = m_dataStore.getInvoices();
+	currentTrackedInvoices.insert(invoice->getId(), util::createNewRecord(invoice));
+	m_dataStore.saveInvoices();
 }
 
 /*
@@ -227,11 +231,12 @@ Returns:
 */
 util::Map<std::string, Invoice*> PaymentManagementService::getInvoices(const std::string& customerID)
 {
-	util::Map<std::string, Invoice*>& currentInvoices = m_dataStore.getInvoices();
+	DataStoreLockGuard lock(m_dataStore);
+	auto& currentTrackedInvoices = m_dataStore.getInvoices();
 	util::Map<std::string, Invoice*> currentUserInvoices;
-	for (int iterator = 0; iterator < currentInvoices.getSize(); iterator++)
+	for (int iterator = 0; iterator < currentTrackedInvoices.getSize(); iterator++)
 	{
-		Invoice* currentInvoice = currentInvoices.getValueAt(iterator);
+		Invoice* currentInvoice = currentTrackedInvoices.getValueAt(iterator).data;
 		if (currentInvoice->getBooking()->getCustomerId() == customerID)
 		{
 			currentUserInvoices.insert(currentInvoice->getId(), currentInvoice);
@@ -254,11 +259,13 @@ Throws:
 */
 void PaymentManagementService::completePayment(const std::string& invoiceID, util::PaymentMode paymentMode)
 {
-	auto& currentInvoices = m_dataStore.getInvoices();
-	int invoiceIndex = currentInvoices.find(invoiceID);
+	DataStoreLockGuard lock(m_dataStore);
+	auto& currentTrackedInvoices = m_dataStore.getInvoices();
+	int invoiceIndex = currentTrackedInvoices.find(invoiceID);
 	if (invoiceIndex != -1)
 	{
-		Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
+		auto& trackedInvoice = currentTrackedInvoices.getValueAt(invoiceIndex);
+		Invoice* invoice = trackedInvoice.data;
 		if (invoice && invoice->getStatus() != util::PaymentStatus::PAID)
 		{
 			User* currentUser = invoice->getBooking()->getCustomer();
@@ -269,12 +276,14 @@ void PaymentManagementService::completePayment(const std::string& invoiceID, uti
 			title = "Payment successful";
 			message = "Payment successful for Invoice ID " + invoiceID;
 			sendNotification(currentUser, title, message);
+			trackedInvoice.state = RecordState::MODIFIED;
 		}
 	}
 	else
 	{
 		throw std::runtime_error("Payment failed: invalid invoice ID.");
 	}
+	m_dataStore.saveInvoices();
 }
 
 /*
@@ -283,11 +292,14 @@ Description: Provides access to all invoices stored in the data store.
 Parameters:
 	- none
 Returns:
-	- util::Map<std::string, Invoice*>&: Map of invoice IDs to invoice objects
+	- util::Map<std::string, Invoice*>: Map of invoice IDs to invoice objects
 */
-util::Map<std::string, Invoice*>& PaymentManagementService::getAllInvoices()
+util::Map<std::string, Invoice*> PaymentManagementService::getAllInvoices()
 {
-	return m_dataStore.getInvoices();
+	DataStoreLockGuard lock(m_dataStore);
+	util::Map<std::string, Invoice*> invoices;
+	invoices = util::getObjects(m_dataStore.getInvoices());
+	return invoices;
 }
 
 /*
@@ -303,20 +315,24 @@ Throws:
 */
 void PaymentManagementService::confirmPayment(const std::string& invoiceID)
 {
-	auto& currentInvoices = m_dataStore.getInvoices();
-	int invoiceIndex = currentInvoices.find(invoiceID);
+	DataStoreLockGuard lock(m_dataStore);
+	auto& currentTrackedInvoices = m_dataStore.getInvoices();
+	int invoiceIndex = currentTrackedInvoices.find(invoiceID);
 	if (invoiceIndex == -1)
 	{
 		throw std::runtime_error("Payment confirmation failed: invalid invoice ID.");
 	}
-	Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
+	auto& trackedInvoice = currentTrackedInvoices.getValueAt(invoiceIndex);
+	Invoice* invoice = trackedInvoice.data;
 	if (!invoice || invoice->getStatus() != util::PaymentStatus::PAID)
 	{
 		throw std::runtime_error("Payment confirmation failed: invoice is not awaiting confirmation.");
 	}
 	User* currentUser = invoice->getBooking()->getCustomer();
 	invoice->setStatus(util::PaymentStatus::COMPLETED);
+	trackedInvoice.state = RecordState::MODIFIED;
 	std::string title = "Payment Confirmed";
 	std::string message = "Payment Confirmed for Invoice ID " + invoiceID;
 	sendNotification(currentUser, title, message);
+	m_dataStore.saveInvoices();
 }

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

@@ -27,7 +27,7 @@ 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();
+    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;