Merge branch 'feature-file-management' into feature-1551-1561-1708

.gitignore

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

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;$(ProjectDir)core\sharedmemory;$(ProjectDir)core\events;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)factories;$(ProjectDir)views;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)core\patterns;$(ProjectDir)datastores;%(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;$(ProjectDir)core\sharedmemory;$(ProjectDir)core\events;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)factories;$(ProjectDir)views;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)core\patterns;$(ProjectDir)datastores;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -126,10 +126,8 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="controllers\Controller.cpp" />
-    <ClCompile Include="core\events\EventManager.cpp" />
     <ClCompile Include="core\patterns\Observer.cpp" />
     <ClCompile Include="core\patterns\Subject.cpp" />
-    <ClCompile Include="core\sharedmemory\SharedMemory.cpp" />
     <ClCompile Include="datastores\DataStore.cpp" />
     <ClCompile Include="models\ComboPackage.cpp" />
     <ClCompile Include="models\InventoryItem.cpp" />
@@ -141,6 +139,7 @@
     <ClCompile Include="models\User.cpp" />
     <ClCompile Include="services\AuthenticationManagementService.cpp" />
     <ClCompile Include="services\InventoryManagementService.cpp" />
+    <ClCompile Include="services\NotificationManagementService.cpp" />
     <ClCompile Include="services\PaymentManagementService.cpp" />
     <ClCompile Include="services\ServiceManagementService.cpp" />
     <ClCompile Include="services\UserManagementService.cpp" />
@@ -149,23 +148,14 @@
     <ClCompile Include="utilities\Validator.cpp" />
     <ClCompile Include="views\AdminMenu.cpp" />
     <ClCompile Include="views\CustomerMenu.cpp" />
-    <ClCompile Include="views\Menu.cpp" />
     <ClCompile Include="views\TechnicianMenu.cpp" />
     <ClCompile Include="views\UserInterface.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="controllers\Controller.h" />
-    <ClInclude Include="core\events\EventManager.h" />
     <ClInclude Include="core\patterns\Observer.h" />
     <ClInclude Include="core\patterns\Subject.h" />
-    <ClInclude Include="core\sharedmemory\FileHeader.h" />
-    <ClInclude Include="core\sharedmemory\MappingInfo.h" />
-    <ClInclude Include="core\sharedmemory\RecordState.h" />
-    <ClInclude Include="core\sharedmemory\SerializedRecords.h" />
-    <ClInclude Include="core\sharedmemory\SharedMemory.h" />
-    <ClInclude Include="core\sharedmemory\TrackedRecord.h" />
     <ClInclude Include="datastores\DataStore.h" />
-    <ClInclude Include="datastores\DataStoreLockGuard.h" />
     <ClInclude Include="factories\Factory.h" />
     <ClInclude Include="models\ComboPackage.h" />
     <ClInclude Include="models\InventoryItem.h" />
@@ -184,6 +174,7 @@
     <ClInclude Include="utilities\Config.h" />
     <ClInclude Include="utilities\Enums.h" />
     <ClInclude Include="utilities\FileHelper.h" />
+    <ClInclude Include="utilities\FileManager.h" />
     <ClInclude Include="utilities\InputHelper.h" />
     <ClInclude Include="utilities\Map.h" />
     <ClInclude Include="utilities\OutputHelper.h" />
@@ -194,7 +185,6 @@
     <ClInclude Include="utilities\Vector.h" />
     <ClInclude Include="views\AdminMenu.h" />
     <ClInclude Include="views\CustomerMenu.h" />
-    <ClInclude Include="views\Menu.h" />
     <ClInclude Include="views\MenuHelper.h" />
     <ClInclude Include="views\TechnicianMenu.h" />
     <ClInclude Include="views\UserInterface.h" />

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

@@ -64,18 +64,6 @@
     <Filter Include="Source Files\Core\Patterns">
       <UniqueIdentifier>{8057b93d-51a9-42df-b06e-01ce395f6308}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Header Files\Core\SharedMemory">
-      <UniqueIdentifier>{d9da9793-fe6f-4914-bee3-99d5934da228}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Source Files\Core\SharedMemory">
-      <UniqueIdentifier>{0769afb6-f57d-4ae3-a1cf-ceca6e606af0}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Header Files\Core\Events">
-      <UniqueIdentifier>{85029bdb-6941-41dc-a3a7-9e5841671d8c}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Source Files\Core\Events">
-      <UniqueIdentifier>{1050aca7-6f2c-4ccb-a446-db9c898c3599}</UniqueIdentifier>
-    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Trenser.VehicleServiceSystem.cpp">
@@ -120,6 +108,9 @@
     <ClCompile Include="datastores\DataStore.cpp">
       <Filter>Source Files\DataStores</Filter>
     </ClCompile>
+    <ClCompile Include="services\NotificationManagementService.cpp">
+      <Filter>Source Files\Services</Filter>
+    </ClCompile>
     <ClCompile Include="core\patterns\Observer.cpp">
       <Filter>Source Files\Core\Patterns</Filter>
     </ClCompile>
@@ -150,15 +141,6 @@
     <ClCompile Include="models\ComboPackage.cpp">
       <Filter>Source Files\Models</Filter>
     </ClCompile>
-    <ClCompile Include="core\sharedmemory\SharedMemory.cpp">
-      <Filter>Source Files\Core\SharedMemory</Filter>
-    </ClCompile>
-    <ClCompile Include="core\events\EventManager.cpp">
-      <Filter>Source Files\Core\Events</Filter>
-    </ClCompile>
-    <ClCompile Include="views\Menu.cpp">
-      <Filter>Source Files\Views</Filter>
-    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="utilities\InputHelper.h">
@@ -254,6 +236,9 @@
     <ClInclude Include="utilities\Config.h">
       <Filter>Header Files\Utilities</Filter>
     </ClInclude>
+    <ClInclude Include="utilities\FileManager.h">
+      <Filter>Header Files\Utilities</Filter>
+    </ClInclude>
     <ClInclude Include="utilities\StringHelper.h">
       <Filter>Header Files\Utilities</Filter>
     </ClInclude>
@@ -266,32 +251,5 @@
     <ClInclude Include="views\MenuHelper.h">
       <Filter>Header Files\Views</Filter>
     </ClInclude>
-    <ClInclude Include="datastores\DataStoreLockGuard.h">
-      <Filter>Header Files\DataStores</Filter>
-    </ClInclude>
-    <ClInclude Include="core\sharedmemory\FileHeader.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="core\sharedmemory\MappingInfo.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="core\sharedmemory\RecordState.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="core\sharedmemory\SerializedRecords.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="core\sharedmemory\SharedMemory.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="core\sharedmemory\TrackedRecord.h">
-      <Filter>Header Files\Core\SharedMemory</Filter>
-    </ClInclude>
-    <ClInclude Include="core\events\EventManager.h">
-      <Filter>Header Files\Core\Events</Filter>
-    </ClInclude>
-    <ClInclude Include="views\Menu.h">
-      <Filter>Header Files\Views</Filter>
-    </ClInclude>
   </ItemGroup>
 </Project>

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

@@ -6,17 +6,10 @@ Description: Implementation file containing the method definitions of the
 Author: Trenser
 Date:19-May-2026
 */
-
-#include "ComboPackage.h"
+#include <stdexcept>
 #include "Controller.h"
 #include "Enums.h"
-#include "InventoryItem.h"
-#include "Invoice.h"
-#include "JobCard.h"
-#include "Service.h"
-#include "ServiceBooking.h"
 #include "User.h"
-#include <stdexcept>
 
 /*
 Function: login
@@ -62,7 +55,6 @@ Parameter: const std::string& username - customer
            const std::string& phone - customer’s phone number
 Return type: void
 */
-
 void Controller::createCustomer(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone)
 {
     m_userManagementService.createUser(username, name, password, email, phone, util::UserType::CUSTOMER);
@@ -79,19 +71,8 @@ const User* Controller::getAuthenticatedUser()
     return m_authenticationManagementService.getAuthenticatedUser();
 }
 
-/*
-Function: createTechnician
-Description: Creates a new technician account with provided details by
-             delegating to the user management service.
-Parameter: const std::string& username - technician's username
-           const std::string& password - technician's password
-           const std::string& email - technician's email address
-           const std::string& phoneNumber - technician's phone number
-Return type: void
-*/
-void Controller::createTechnician(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phoneNumber)
+void Controller::createTechnician(const std::string& username, const std::string& password, const std::string& email, const std::string& phone)
 {
-    m_userManagementService.createUser(username, name, password, email, phoneNumber, util::UserType::TECHNICIAN);
 }
 
 /*
@@ -111,45 +92,14 @@ void Controller::updateUserDetails(const std::string& email, const std::string&
     m_userManagementService.updateUserDetails(authenticatedUser->getId(), email, phone);
 }
 
-/*
-Function: getServices
-Description: Retrieves all available services in read-only form.
-Parameters:
-    - None
-Returns:
-    - util::Map<std::string, const Service*> containing all services
-*/
 util::Map<std::string, const Service*> Controller::getServices()
 {
-    util::Map<std::string, Service*> currentServices = m_serviceManagementService.getServices();
-    util::Map<std::string, const Service*> readOnlyServices;
-    for (int iterator = 0; iterator < currentServices.getSize(); iterator++)
-    {
-        readOnlyServices.insert(currentServices.getValueAt(iterator)->getId(), currentServices.getValueAt(iterator));
-    }
-    return readOnlyServices;
+    return util::Map<std::string, const Service*>();
 }
 
-/*
-Function: getComboPackages
-Description: Retrieves all available combo packages from the service
-             management service and constructs a read-only map.
-Parameter: None
-Return type: util::Map<std::string, const ComboPackage*>
-*/
 util::Map<std::string, const ComboPackage*> Controller::getComboPackages()
 {
-    util::Map<std::string, ComboPackage*> currentAvailableComboPackages = m_serviceManagementService.getComboPackages();
-    util::Map<std::string, const ComboPackage*> readOnlyComboPackages;
-    for (int iterator = 0; iterator < currentAvailableComboPackages.getSize(); iterator++)
-    {
-        ComboPackage* currentComboPackage = currentAvailableComboPackages.getValueAt(iterator);
-        if (currentComboPackage)
-        {
-            readOnlyComboPackages.insert(currentComboPackage->getId(), currentComboPackage);
-        }
-    }
-    return readOnlyComboPackages;
+    return util::Map<std::string, const ComboPackage*>();
 }
 
 /*
@@ -180,345 +130,84 @@ void Controller::purchaseComboPackage(const std::string& comboPackageID, const s
     m_serviceManagementService.purchaseComboPackage(comboPackageID, vehicleNumber, vehicleBrand, vehicleModel);
 }
 
-/*
-Function: getInventoryItems
-Description: Retrieves all inventory items from the inventory management service
-             and constructs a read-only map for external use.
-Parameter: None
-Return type: util::Map<std::string, const InventoryItem*>
-*/
 util::Map<std::string, const InventoryItem*> Controller::getInventoryItems()
 {
-    auto inventoryItems = m_inventoryManagementService.getInventoryItems();
-    util::Map<std::string, const InventoryItem*> readOnlyInventoryItems;
-    int inventoryItemsMapSize = inventoryItems.getSize();
-    for (int index = 0; index < inventoryItemsMapSize; index++)
-    {
-        readOnlyInventoryItems.insert(inventoryItems.getKeyAt(index), inventoryItems.getValueAt(index));
-    }
-    return readOnlyInventoryItems;
+    return util::Map<std::string, const InventoryItem*>();
 }
 
-/*
-Function: getInventoryItem
-Description: Retrieves a specific inventory item by its ID from the inventory management service.
-Parameter: const std::string& inventoryItemID - ID of the inventory item
-Return type: const InventoryItem*
-*/
 const InventoryItem* Controller::getInventoryItem(const std::string& inventoryItemID)
 {
-    return m_inventoryManagementService.getInventoryItem(inventoryItemID);
+    return nullptr;
 }
 
-/*
-Function: addInventoryItem
-Description: Adds a new inventory item with specified details to the inventory management service.
-Parameter: const std::string& partName - name of the part
-           int quantity - quantity of the part
-           double price - price of the part
-Return type: void
-*/
 void Controller::addInventoryItem(const std::string& partName, int quantity, double price)
 {
-    m_inventoryManagementService.addInventoryItem(partName, quantity, price);
 }
 
-/*
-Function: removeInventoryItem
-Description: Removes an inventory item from the inventory management service by its ID.
-Parameter: const std::string& inventoryItemID - ID of the inventory item
-Return type: void
-*/
 void Controller::removeInventoryItem(const std::string& inventoryItemID)
 {
-    m_inventoryManagementService.removeInventoryItem(inventoryItemID);
 }
 
-/*
-Function: removeServiceBooking
-Description: Removes a service booking from the service management system by its booking ID.
-Parameter: const std::string& bookingID - ID of the service booking
-Return type: void
-*/
-void Controller::removeServiceBooking(const std::string& bookingID)
-{
-    m_serviceManagementService.removeServiceBooking(bookingID);
-}
-
-/*
-Function: addInventoryItemStock
-Description: Adds stock to an existing inventory item in the inventory management service.
-Parameter: const std::string& selectedItemId - ID of the inventory item
-           int quantity - quantity to add
-Return type: void
-*/
-void Controller::addInventoryItemStock(const std::string& selectedItemId, int quantity)
-{
-    m_inventoryManagementService.addInventoryItemStock(selectedItemId, quantity);
-}
-
-/*
-Function: getServiceBookings
-Description: Retrieves all service bookings in read-only form.
-Parameters:
-    - None
-Returns:
-    - util::Map<std::string, const ServiceBooking*> containing service bookings
-*/
 util::Map<std::string, const ServiceBooking*> Controller::getServiceBookings()
 {
-    auto serviceBookings = m_serviceManagementService.getServiceBookings();
-    util::Map<std::string, const ServiceBooking*> readOnlyServiceBookings;
-    for (int iterator = 0; iterator < serviceBookings.getSize(); iterator++)
-    {
-        readOnlyServiceBookings.insert(serviceBookings.getKeyAt(iterator), serviceBookings.getValueAt(iterator));
-    }
-    return readOnlyServiceBookings;
+    return util::Map<std::string, const ServiceBooking*>();
 }
 
-
-/*
-Function: getServiceBookingsByUser
-Description: Retrieves all service bookings for a specific user.
-Parameters:
-    - userID: std::string, the user ID
-Returns:
-    - util::Map<std::string, const ServiceBooking*> containing bookings for the user
-*/
 util::Map<std::string, const ServiceBooking*> Controller::getServiceBookingsByUser(const std::string userID)
 {
-    util::Map<std::string, const ServiceBooking*> readOnlyServiceBookingsByUserMap;
-    util::Map<std::string, ServiceBooking*> currentServiceBookingsByUser = m_serviceManagementService.getServiceBookings(userID);
-    for (int iterator = 0; iterator < currentServiceBookingsByUser.getSize(); iterator++)
-    {
-        readOnlyServiceBookingsByUserMap.insert(currentServiceBookingsByUser.getValueAt(iterator)->getId(), currentServiceBookingsByUser.getValueAt(iterator));
-    }
-    return readOnlyServiceBookingsByUserMap;
+    return util::Map<std::string, const ServiceBooking*>();
 }
 
-/*
-Function: getUsers
-Description: Retrieves all users from the user management service and
-             constructs a read-only map.
-Parameter: None
-Return type: util::Map<std::string, const User*>
-*/
 util::Map<std::string, const User*> Controller::getUsers()
 {
-    auto listOfUsers = m_userManagementService.getUsers();
-    util::Map<std::string, const User*> readOnlyUserList;
-    for (int iterator = 0; iterator < listOfUsers.getSize(); iterator++)
-    {
-        readOnlyUserList.insert(listOfUsers.getKeyAt(iterator), listOfUsers.getValueAt(iterator));
-    }
-    return readOnlyUserList;
+    return util::Map<std::string, const User*>();
 }
 
-/*
-Function: getUsers
-Description: Retrieves users filtered by user type.
-Parameters:
-    - userType: util::UserType, type of user (CUSTOMER, TECHNICIAN, ADMIN)
-Returns:
-    - util::Map<std::string, const User*> containing users of the specified type
-*/
 util::Map<std::string, const User*> Controller::getUsers(util::UserType userType)
 {
-    auto userMap = m_userManagementService.getUsers(userType);
-    util::Map<std::string, const User*> readOnlyUserMap;
-    for (int iterator = 0; iterator < userMap.getSize(); iterator++)
-    {
-        readOnlyUserMap.insert(userMap.getKeyAt(iterator), userMap.getValueAt(iterator));
-    }
-    return readOnlyUserMap;
+    return util::Map<std::string, const User*>();
 }
 
-/*
-Function: createJobCard
-Description: Creates a job card for a service booking assigned to a technician.
-Parameters:
-    - bookingID: std::string, ID of the service booking
-    - technicianID: std::string, ID of the technician
-    - serviceID: std::string, ID of the service
-Returns:
-    - void
-*/
 void Controller::createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID)
 {
-    m_serviceManagementService.createJobCard(bookingID, technicianID, serviceID);
 }
 
-/*
-Function: createService
-Description: Creates a new service with associated inventory items and labor cost.
-Parameters:
-    - name: std::string, name of the service
-    - inventoryItemIDs: Vector of inventory item IDs
-    - laborCost: double, labor cost
-Returns:
-    - void
-*/
 void Controller::createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost)
 {
-    m_serviceManagementService.createService(name, inventoryItemIDs, laborCost);
 }
 
-/*
-Function: removeService
-Description: Removes a service from the system by ID.
-Parameters:
-    - serviceID: std::string, ID of the service
-Returns:
-    - void
-*/
 void Controller::removeService(const std::string& serviceID)
 {
-    m_serviceManagementService.removeService(serviceID);
 }
 
-/*
-Function: getJobCardsByUser
-Description: Retrieves job cards assigned to the authenticated technician.
-Parameters:
-    - None
-Returns:
-    - util::Map<std::string, const JobCard*> containing job cards
-*/
 util::Map<std::string, const JobCard*> Controller::getJobCardsByUser()
 {
-    const User* currentUser = getAuthenticatedUser();
-    auto jobCardsAssignedToTechnician = m_serviceManagementService.getJobCards(currentUser->getId());
-    util::Map<std::string, const JobCard*> readOnlyJobCardMap;
-    for (int iterator = 0; iterator < jobCardsAssignedToTechnician.getSize(); iterator++)
-    {
-        JobCard* currentJobCard = jobCardsAssignedToTechnician.getValueAt(iterator);
-        readOnlyJobCardMap.insert(currentJobCard->getId(), currentJobCard);
-    }
-    return readOnlyJobCardMap;
+    return util::Map<std::string, const JobCard*>();
 }
 
-/*
-Function: completeJob
-Description: Marks a job card as completed.
-Parameters:
-    - jobID: std::string, ID of the job card
-Returns:
-    - void
-*/
-void Controller::updateJobStatus(const std::string& jobID)
+void Controller::completeJob(const std::string& jobID)
 {
-    m_serviceManagementService.updateJobStatus(jobID);
 }
 
-/*
-Function: removeUser
-Description: Removes a user by ID. Cancels associated service bookings
-             and technician jobs before removing the user from the system.
-Parameter: const std::string& userID - ID of the user to remove
-Return type: void
-*/
 void Controller::removeUser(const std::string& userID)
 {
-    User* user = m_userManagementService.getUser(userID);
-    if (!user)
-    {
-        throw std::runtime_error("Error: User not Found.\n");
-    }
-    m_userManagementService.removeUser(userID);
 }
 
-/*
-Function: createComboPackage
-Description: Creates a new combo package with specified services and discount
-             percentage by delegating to the service management service.
-Parameter: const std::string& name - name of the combo package
-           const util::Vector<std::string>& serviceIDs - list of service IDs
-           double discountPercentage - discount percentage for the package
-Return type: void
-*/
 void Controller::createComboPackage(const std::string& name, const util::Vector<std::string>& serviceIDs, double discountPercentage)
 {
-    m_serviceManagementService.createComboPackage(name, serviceIDs, discountPercentage);
 }
 
-/*
-Function: removeComboPackage
-Description: Removes a combo package by ID by delegating to the service
-             management service.
-Parameter: const std::string& comboPackageID - ID of the combo package
-Return type: void
-*/
 void Controller::removeComboPackage(const std::string& comboPackageID)
 {
-    m_serviceManagementService.removeComboPackage(comboPackageID);
 }
 
-/*
-Function: getInvoicesByUser
-Description: Retrieves all invoices associated with the currently authenticated user.
-             Converts them into a read-only map before returning.
-Parameters:
-    - None
-Returns:
-    - util::Map<std::string, const Invoice*> containing the user’s invoices
-*/
 util::Map<std::string, const Invoice*> Controller::getInvoicesByUser()
 {
-    User* currentUser = m_authenticationManagementService.getAuthenticatedUser();
-    util::Map<std::string, Invoice*> currentUserInvoices =  m_paymentManagementService.getInvoices(currentUser->getId());
-    util::Map<std::string, const Invoice*> userInvoicesReadOnly;
-    for (int iterator = 0; iterator < currentUserInvoices.getSize(); iterator++)
-    {
-        Invoice* currentInvoice = currentUserInvoices.getValueAt(iterator);
-        userInvoicesReadOnly.insert(currentInvoice->getId(), currentInvoice);
-    }
-    return userInvoicesReadOnly;
+    return util::Map<std::string, const Invoice*>();
 }
 
-/*
-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.
-Parameters:
-    - invoiceID: std::string, ID of the invoice to be paid
-    - paymentMode: util::PaymentMode, mode of payment (e.g., ONLINE, OFFLINE)
-Returns:
-    - void
-*/
 void Controller::completePayment(const std::string& invoiceID, util::PaymentMode paymentMode)
 {
-    m_paymentManagementService.completePayment(invoiceID, paymentMode);
 }
 
 /*
@@ -600,50 +289,63 @@ void Controller::configureNotifications(bool paymentNotifications, bool serviceN
 }
 
 /*
-Function: initialize
-Description: Initializes the system and run system checks to ensure critical configurations, such as verifying admin existence.
-Parameters:
-    - None
-Returns:
-    - bool
-*/
-bool Controller::initialize()
-{
-    auto& dataStore = DataStore::getInstance();
-
-    if (!dataStore.initialize())
-    {
-        return false;
-    }
-    m_userManagementService.ensureAdminExists();
-    m_inventoryManagementService.sendLowStockAlerts();
-    m_paymentManagementService.sendPaymentReminders();
-    return true;
-}
-
-/*
-Function: shutdown
-Description: Shutdown the system, and do necessary cleanups
+Function: loadSystemData
+Description: Loads all system data from persistent storage into memory.
+             Invokes the respective management services to load users, inventory items, services,
+             combo packages, service bookings, job cards, invoices, and observers.
 Parameters:
     - None
 Returns:
     - void
 */
-void Controller::shutdown()
+void Controller::loadSystemData()
 {
-    auto& dataStore = DataStore::getInstance();
-    dataStore.shutdown();
+    m_userManagementService.loadUsers();
+    m_inventoryManagementService.loadInventoryItems();
+    m_serviceManagementService.loadServices();
+    m_serviceManagementService.loadComboPackages();
+    m_serviceManagementService.loadServiceBookings();
+    m_serviceManagementService.loadJobCards();
+    m_paymentManagementService.loadInvoices();
+    m_serviceManagementService.loadObservers();
+    m_paymentManagementService.loadObservers();
+    m_inventoryManagementService.loadObservers();
 }
 
 /*
-Function: registerEvents
-Description: Registers menu event handles with the authentication
-             service.
-Parameter: HANDLE accountDisabledEvent - account disabled event handle
-           HANDLE notificationAvailableEvent - notification event handle
+Function: saveSystemData
+Description: Saves all system data from memory back to persistent storage.
+             Invokes the respective management services to save users, inventory items, services,
+             combo packages, service bookings, job cards, invoices, and observers.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void Controller::saveSystemData()
+{
+    m_userManagementService.saveUsers();
+    m_inventoryManagementService.saveInventoryItems();
+    m_serviceManagementService.saveServices();
+    m_serviceManagementService.saveComboPackages();
+    m_serviceManagementService.saveServiceBookings();
+    m_serviceManagementService.saveJobCards();
+    m_paymentManagementService.saveInvoices();
+    m_serviceManagementService.saveObservers();
+    m_paymentManagementService.saveObservers();
+    m_inventoryManagementService.saveObservers();
+}
+
+/*
+Function: runSystemChecks
+Description: Runs system checks to ensure critical configurations, such as verifying admin existence.
+Parameter: None
 Return type: void
 */
-void Controller::registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent)
+void Controller::runSystemChecks()
 {
-    m_authenticationManagementService.registerEvents(accountDisabledEvent, notificationAvailableEvent);
+    m_userManagementService.ensureAdminExists();
+    m_inventoryManagementService.sendLowStockAlerts();
+    m_paymentManagementService.sendPaymentReminders();
 }
+

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

@@ -1,14 +1,12 @@
 /*
 File: Controller.h
-Description: Header file declaring the Controller class, which manages
-             user authentication, inventory, services, bookings, job cards,
-             invoices, and notifications in the system.
+Description: Header file declaring the Controller class, which coordinates
+             authentication, user management, service management, inventory,
+             and notifications across the Vehicle Service System.
 Author: Trenser
 Date:19-May-2026
 */
-
 #pragma once
-#include <windows.h>
 #include <string>
 #include "AuthenticationManagementService.h"
 #include "Enums.h"
@@ -17,6 +15,10 @@ Date:19-May-2026
 #include "PaymentManagementService.h"
 #include "ServiceManagementService.h"
 #include "UserManagementService.h"
+#include "InventoryManagementService.h"
+#include "UserManagementService.h"
+#include "ServiceManagementService.h"
+#include "PaymentManagementService.h"
 
 class Service;
 class ComboPackage;
@@ -41,7 +43,7 @@ public:
     void changePassword(const std::string& newPassword);
     void createCustomer(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone);
     const User* getAuthenticatedUser();
-    void createTechnician(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone);
+    void createTechnician(const std::string& username, const std::string& password, const std::string& email, const std::string& phone);
     void updateUserDetails(const std::string& email, const std::string& phone);
     util::Map<std::string, const Service*> getServices();
     util::Map<std::string, const ComboPackage*> getComboPackages();
@@ -50,7 +52,6 @@ public:
     util::Map<std::string, const InventoryItem*> getInventoryItems();
     const InventoryItem* getInventoryItem(const std::string& inventoryItemID);
     void addInventoryItem(const std::string& partName, int quantity, double price);
-    void addInventoryItemStock(const std::string& selectedItemId, int quantity);
     void removeInventoryItem(const std::string& inventoryItemID);
     util::Map<std::string, const ServiceBooking*> getServiceBookings();
     util::Map<std::string, const ServiceBooking*> getServiceBookingsByUser(const std::string userID);
@@ -58,21 +59,18 @@ public:
     util::Map<std::string, const User*> getUsers(util::UserType userType);
     void createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID);
     void createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost);
-    void removeServiceBooking(const std::string& bookingID);
     void removeService(const std::string& serviceID);
     util::Map<std::string, const JobCard*> getJobCardsByUser();
-    void updateJobStatus(const std::string& jobID);
+    void completeJob(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);
     void configureNotifications(bool paymentNotifications, bool serviceNotifications);
-    bool initialize();
-    void shutdown();
-    void registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent);
+    void loadSystemData();
+    void saveSystemData();
+    void runSystemChecks();
 };

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/core/events/EventManager.cpp

@@ -1,225 +0,0 @@
-/*
-File: EventManager.cpp
-Description: Implementation file containing the method definitions of the
-             EventManager class, including listener management and
-             interprocess event publishing.
-Author: Trenser
-Date:15-Jun-2026
-*/
-
-#include <iostream>
-#include <stdexcept>
-#include "EventManager.h"
-
-namespace
-{
-    const std::string USER_DISABLED_EVENT = "userDisabled_";
-
-    const std::string NOTIFICATION_AVAILABLE_EVENT = "notificationAvailable_";
-}
-
-/*
-Function: EventManager
-Description: Constructs an EventManager instance with default values.
-Parameter: None
-Return type: None
-*/
-EventManager::EventManager()
-    :
-    m_userDisabledEvent(NULL),
-    m_notificationAvailableEvent(NULL),
-    m_shutdownEvent(NULL),
-    m_running(false) {}
-
-/*
-Function: ~EventManager
-Description: Destroys the EventManager and performs final cleanup.
-Parameter: None
-Return type: None
-*/
-EventManager::~EventManager()
-{
-    shutdown();
-    if (m_listenerThread.joinable())
-    {
-        m_listenerThread.join();
-    }
-}
-
-/*
-Function: initialize
-Description: Creates the user-specific events and starts the listener
-             thread.
-Parameter: const std::string& userId - unique identifier of the user
-           std::function<void()> userDisabledCallback - callback for
-           user disable events
-           std::function<void()> notificationCallback - callback for
-           notification events
-Return type: bool - true if initialization succeeds, false otherwise
-*/
-bool EventManager::initialize(const std::string& userId, std::function<void()> userDisabledCallback, std::function<void()> notificationCallback)
-{
-    if (m_running.load())
-    {
-        return false;
-    }
-    m_userDisabledCallback = userDisabledCallback;
-    m_notificationCallback = notificationCallback;
-    m_userDisabledEvent = CreateEventA(NULL, FALSE, FALSE, (USER_DISABLED_EVENT + userId).c_str());
-    if (!m_userDisabledEvent)
-    {
-        return false;
-    }
-    if (GetLastError() == ERROR_ALREADY_EXISTS)
-    {
-        CloseHandle(m_userDisabledEvent);
-        m_userDisabledEvent = NULL;
-        throw std::runtime_error("Only one session allowed per user.");
-    }
-    m_notificationAvailableEvent = CreateEventA(NULL, FALSE, FALSE, (NOTIFICATION_AVAILABLE_EVENT + userId).c_str());
-    if (!m_notificationAvailableEvent)
-    {
-        CloseHandle(m_userDisabledEvent);
-        m_userDisabledEvent = NULL;
-        return false;
-    }
-    m_shutdownEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
-    if (!m_shutdownEvent)
-    {
-        CloseHandle(m_userDisabledEvent);
-        CloseHandle(m_notificationAvailableEvent);
-        m_userDisabledEvent = NULL;
-        m_notificationAvailableEvent = NULL;
-        return false;
-    }
-    m_running.store(true);
-    m_listenerThread = std::thread(&EventManager::run, this);
-    return true;
-}
-
-/*
-Function: shutdown
-Description: Stops the listener thread and releases event resources.
-Parameter: None
-Return type: None
-*/
-void EventManager::shutdown()
-{
-    if (!m_running.load())
-    {
-        return;
-    }
-    m_running.store(false);
-    if (m_shutdownEvent)
-    {
-        SetEvent(m_shutdownEvent);
-    }
-    if (m_listenerThread.joinable())
-    {
-        if (std::this_thread::get_id() != m_listenerThread.get_id())
-        {
-            m_listenerThread.join();
-        }
-    }
-    if (m_userDisabledEvent)
-    {
-        CloseHandle(m_userDisabledEvent);
-        m_userDisabledEvent = NULL;
-    }
-    if (m_notificationAvailableEvent)
-    {
-        CloseHandle(m_notificationAvailableEvent);
-        m_notificationAvailableEvent = NULL;
-    }
-    if (m_shutdownEvent)
-    {
-        CloseHandle(m_shutdownEvent);
-        m_shutdownEvent = NULL;
-    }
-}
-
-/*
-Function: run
-Description: Waits for and dispatches user-related events.
-Parameter: None
-Return type: void
-*/
-void EventManager::run()
-{
-    HANDLE handles[3];
-    handles[0] = m_userDisabledEvent;
-    handles[1] = m_notificationAvailableEvent;
-    handles[2] = m_shutdownEvent;
-    while (m_running.load())
-    {
-        DWORD result = WaitForMultipleObjects(3, handles, FALSE, INFINITE);
-        switch (result)
-        {
-        case WAIT_OBJECT_0:
-            try
-            {
-                if (m_userDisabledCallback)
-                {
-                    m_userDisabledCallback();
-                }
-            }
-            catch (const std::exception& exception)
-            {
-                std::cout << exception.what() << std::endl;
-            }
-            break;
-        case WAIT_OBJECT_0 + 1:
-            try
-            {
-                if (m_notificationCallback)
-                {
-                    m_notificationCallback();
-                }
-            }
-            catch (const std::exception& exception)
-            {
-                std::cout << exception.what() << std::endl;
-            }
-            break;
-        case WAIT_OBJECT_0 + 2:
-            return;
-        default:
-            break;
-        }
-    }
-}
-
-/*
-Function: sendUserDisabledEvent
-Description: Publishes a user disabled event for a specific user.
-Parameter: const std::string& userId - target user identifier
-Return type: void
-*/
-void EventManager::sendUserDisabledEvent(const std::string& userId)
-{
-    HANDLE eventHandle = CreateEventA(NULL, FALSE, FALSE, (USER_DISABLED_EVENT + userId).c_str());
-    if (!eventHandle)
-    {
-        return;
-    }
-    SetEvent(eventHandle);
-    CloseHandle(eventHandle);
-}
-
-/*
-Function: sendNotificationAvailableEvent
-Description: Publishes a notification available event for a specific
-             user.
-Parameter: const std::string& userId - target user identifier
-Return type: void
-*/
-void EventManager::sendNotificationAvailableEvent(const std::string& userId)
-{
-    HANDLE eventHandle = CreateEventA(NULL, FALSE, FALSE, (NOTIFICATION_AVAILABLE_EVENT + userId).c_str());
-    if (!eventHandle)
-    {
-        return;
-    }
-    SetEvent(eventHandle);
-    CloseHandle(eventHandle);
-}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/core/events/EventManager.h

@@ -1,37 +0,0 @@
-/*
-File: EventManager.h
-Description: Header file declaring the EventManager class, which manages
-             user-specific interprocess events for user disable and
-             notification availability updates.
-Author: Trenser
-Date:15-Jun-2026
-*/
-
-#pragma once
-
-#include <windows.h>
-#include <atomic>
-#include <functional>
-#include <string>
-#include <thread>
-
-class EventManager
-{
-private:
-    HANDLE m_userDisabledEvent;
-    HANDLE m_notificationAvailableEvent;
-    HANDLE m_shutdownEvent;
-    std::atomic<bool> m_running;
-    std::thread m_listenerThread;
-    std::function<void()> m_userDisabledCallback;
-    std::function<void()> m_notificationCallback;
-    void run();
-
-public:
-    EventManager();
-    ~EventManager();
-    bool initialize(const std::string& userId, std::function<void()> userDisabledCallback, std::function<void()> notificationCallback);
-    void shutdown();
-    static void sendUserDisabledEvent(const std::string& userId);
-    static void sendNotificationAvailableEvent(const std::string& userId);
-};

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

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

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/core/sharedmemory/FileHeader.h

@@ -1,17 +0,0 @@
-/*
-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/core/sharedmemory/MappingInfo.h

@@ -1,29 +0,0 @@
-/*
-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/core/sharedmemory/RecordState.h

@@ -1,17 +0,0 @@
-/*
-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/core/sharedmemory/SerializedRecords.h

@@ -1,109 +0,0 @@
-/*
-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/core/sharedmemory/SharedMemory.cpp

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

@@ -1,29 +0,0 @@
-/*
-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/core/sharedmemory/TrackedRecord.h

@@ -1,33 +0,0 @@
-/*
-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/datastores/DataStore.cpp

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

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

@@ -6,248 +6,42 @@ Date: 19-May-2026
 */
 
 #pragma once
-#include <windows.h>
 #include <string>
 #include "Map.h"
-#include "MappingInfo.h"
-#include "TrackedRecord.h"
-#include "SerializedRecords.h"
-#include "SharedMemory.h"
-#include "User.h"
-#include "Notification.h"
-#include "Service.h"
-#include "ComboPackage.h"
-#include "InventoryItem.h"
-#include "ServiceBooking.h"
-#include "JobCard.h"
-#include "Invoice.h"
+
+class User;
+class Service;
+class ComboPackage;
+class ServiceBooking;
+class JobCard;
+class InventoryItem;
+class Invoice;
+class Payment;
 
 class DataStore
 {
 private:
-    DataStore();
-    ~DataStore();
+    util::Map<std::string, User*> m_users;
+    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;
-    HANDLE m_globalMutex;
-    MappingInfo m_users;
-    MappingInfo m_notifications;
-    MappingInfo m_services;
-    MappingInfo m_comboPackages;
-    MappingInfo m_inventoryItems;
-    MappingInfo m_serviceBookings;
-    MappingInfo m_jobCards;
-    MappingInfo m_invoices;
-    MappingInfo m_serviceManagementObservers;
-    MappingInfo m_paymentManagementObservers;
-    MappingInfo m_inventoryManagementObservers;
-    util::Map<std::string, TrackedRecord<User>> m_userCache;
-    util::Map<std::string, TrackedRecord<Notification>> m_notificationCache;
-    util::Map<std::string, TrackedRecord<Service>> m_serviceCache;
-    util::Map<std::string, TrackedRecord<ComboPackage>> m_comboPackageCache;
-    util::Map<std::string, TrackedRecord<InventoryItem>> m_inventoryItemCache;
-    util::Map<std::string, TrackedRecord<ServiceBooking>> m_serviceBookingCache;
-    util::Map<std::string, TrackedRecord<JobCard>> m_jobCardCache;
-    util::Map<std::string, TrackedRecord<Invoice>> m_invoiceCache;
-public:
-    static DataStore& getInstance();
-    bool initialize();
-    void shutdown();
-    util::Map<std::string, TrackedRecord<User>>& getUsers();
-    util::Map<std::string, TrackedRecord<Notification>>& getNotifications();
-    util::Map<std::string, TrackedRecord<Service>>& getServices();
-    util::Map<std::string, TrackedRecord<ComboPackage>>& getComboPackages();
-    util::Map<std::string, TrackedRecord<InventoryItem>>& getInventoryItems();
-    util::Map<std::string, TrackedRecord<ServiceBooking>>& getServiceBookings();
-    util::Map<std::string, TrackedRecord<JobCard>>& getJobCards();
-    util::Map<std::string, TrackedRecord<Invoice>>& getInvoices();
-    util::Map<std::string, User*> getServiceManagementObservers();
-    util::Map<std::string, User*> getPaymentManagementObservers();
-    util::Map<std::string, User*> getInventoryManagementObservers();
-    void saveUsers();
-    void saveNotifications();
-    void saveServices();
-    void saveComboPackages();
-    void saveInventoryItems();
-    void saveServiceBookings();
-    void saveJobCards();
-    void saveInvoices();
-    void saveServiceManagementObservers(util::Map<std::string, User*>& observers);
-    void savePaymentManagementObservers(util::Map<std::string, User*>& observers);
-    void saveInventoryManagementObservers(util::Map<std::string, User*>& observers);
-    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);
-    template<typename TObject> void clearCache(util::Map<std::string, TrackedRecord<TObject>>&cache);
-    template<typename TObject> void refreshCache(util::Map<std::string, TrackedRecord<TObject>>&cache, util::Map<std::string, TrackedRecord<TObject>>&refreshedCache);
-    util::Map<std::string, User*> getObservers(MappingInfo& mapping);
-    void saveObservers(MappingInfo& mapping, util::Map<std::string, User*>& observers);
+    util::Map<std::string, User*>& getUsers();
+    util::Map<std::string, Service*>& getServices();
+    util::Map<std::string, ComboPackage*>& getComboPackages();
+    util::Map<std::string, ServiceBooking*>& getServiceBookings();
+    util::Map<std::string, JobCard*>& getJobCards();
+    util::Map<std::string, InventoryItem*>& getInventoryItems();
+    util::Map<std::string, Invoice*>& getInvoices();
+    util::Map<std::string, Payment*>& getPayments();
 };
-
-/*
-Function: loadRecords
-Description: Loads all serialized records from the specified
-             shared-memory mapping, deserializes them into
-             application objects, and returns them as a map
-             of tracked records. Each loaded record is marked
-             as CLEAN and assigned its corresponding slot index
-             within the mapping so that future modifications
-             can be written back efficiently.
-Parameter:
-    - mapping: Reference to the mapping containing the
-               serialized records.
-Return type:
-    util::Map<std::string, TrackedRecord<TObject>>
-             A map containing all loaded records keyed by
-             their unique identifier.
-*/
-template<typename TObject, typename TSerialized>
-util::Map<std::string, TrackedRecord<TObject>> DataStore::loadRecords(MappingInfo& mapping)
-{
-    util::Map<std::string, TrackedRecord<TObject>> records;
-    SharedMemory::ensureLatestMapping(mapping);
-    size_t recordCount = SharedMemory::getRecordCount(mapping);
-    for (size_t index = 0; index < recordCount; ++index)
-    {
-        TSerialized* serialized = static_cast<TSerialized*>(SharedMemory::getRecordAddress(mapping,index));
-        TObject* object = TObject::deserialize(*serialized);
-        TrackedRecord<TObject> trackedRecord;
-        trackedRecord.data = object;
-        trackedRecord.state = RecordState::CLEAN;
-        trackedRecord.slotIndex = index;
-        records.insert(object->getId(), trackedRecord);
-    }
-    return records;
-}
-
-/*
-Function: saveRecords
-Description: Persists all modified and newly added records
-             contained in the provided map to the specified
-             shared-memory mapping. Modified records overwrite
-             their existing slots, while new records are
-             appended to the end of the mapping. Records marked
-             as CLEAN are ignored.
-Parameter:
-    - mapping: Reference to the mapping where records are
-               stored.
-    - records: Map containing the records to be persisted.
-Return type: void
-*/
-template<typename TObject, typename TSerialized> void DataStore::saveRecords(MappingInfo& mapping, util::Map<std::string, TrackedRecord<TObject>>& records)
-{
-    SharedMemory::ensureLatestMapping(mapping);
-    for (int index = 0; index < records.getSize(); ++index)
-    {
-        TrackedRecord<TObject>& record = records.getValueAt(index);
-        if (record.state == RecordState::CLEAN)
-        {
-            continue;
-        }
-        TSerialized serialized = record.data->serialize();
-        if (record.state == RecordState::MODIFIED)
-        {
-            TSerialized* destination = static_cast<TSerialized*>(SharedMemory::getRecordAddress(mapping, record.slotIndex));
-            if (destination)
-            {
-                *destination = serialized;
-            }
-        }
-        else if (record.state == RecordState::NEW_RECORD)
-        {
-            if (!SharedMemory::ensureCapacityForInsert(mapping))
-            {
-                continue;
-            }
-            size_t recordCount = SharedMemory::getRecordCount(mapping);
-            TSerialized* destination = static_cast<TSerialized*>(SharedMemory::getRecordAddress(mapping,recordCount));
-            *destination = serialized;
-            SharedMemory::setRecordCount(mapping, recordCount + 1);
-            record.slotIndex = recordCount;
-        }
-        record.state = RecordState::CLEAN;
-    }
-}
-
-/*
-Function: clearCache
-Description: Releases all objects owned by the cache and
-             clears the cache contents.
-Parameters:
-    - cache: Cache to be cleared.
-Returns:
-    - None
-*/
-template<typename TObject>
-void DataStore::clearCache(util::Map<std::string, TrackedRecord<TObject>>&cache)
-{
-    for (int index = 0; index < cache.getSize(); ++index)
-    {
-        delete cache.getValueAt(index).data;
-        cache.getValueAt(index).data = nullptr;
-    }
-    cache.clear();
-}
-
-/*
-Function: refreshCache
-Description: Refreshes the cache while preserving object addresses
-             for records that already exist. Existing objects are
-             updated in-place so that pointers held elsewhere remain
-             valid after the refresh.
-Parameters:
-    - cache: Existing cache to refresh.
-    - refreshedCache: Newly loaded cache contents.
-Returns:
-    - None
-*/
-template<typename TObject>
-void DataStore::refreshCache(util::Map<std::string, TrackedRecord<TObject>>& cache, util::Map<std::string, TrackedRecord<TObject>>& refreshedCache)
-{
-    util::Map<std::string, TrackedRecord<TObject>> oldCache = cache;
-    cache.clear();
-    for (int index = 0; index < refreshedCache.getSize(); ++index)
-    {
-        const std::string& id = refreshedCache.getKeyAt(index);
-        TrackedRecord<TObject>& refreshedRecord = refreshedCache.getValueAt(index);
-        int oldIndex = oldCache.find(id);
-        if (oldIndex != -1)
-        {
-            TrackedRecord<TObject>& oldRecord = oldCache.getValueAt(oldIndex);
-            if (oldRecord.state == RecordState::MODIFIED)
-            {
-                delete refreshedRecord.data;
-                cache.insert(id, oldRecord);
-                continue;
-            }
-            *oldRecord.data = *refreshedRecord.data;
-            oldRecord.slotIndex = refreshedRecord.slotIndex;
-            oldRecord.state = refreshedRecord.state;
-            delete refreshedRecord.data;
-            refreshedRecord.data = oldRecord.data;
-        }
-        cache.insert(id, refreshedRecord);
-    }
-    for (int index = 0; index < oldCache.getSize(); ++index)
-    {
-        const std::string& id = oldCache.getKeyAt(index);
-        const TrackedRecord<TObject>& localTrackedRecord = oldCache.getValueAt(index);
-        if (cache.find(id) == -1)
-        {
-            if (localTrackedRecord.state == RecordState::NEW_RECORD)
-            {
-                cache.insert(id, localTrackedRecord);
-            }
-            else
-            {
-                delete localTrackedRecord.data;
-            }
-        }
-    }
-}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/datastores/DataStoreLockGuard.h

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

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/files/README.md

@@ -0,0 +1 @@
+Place files here.

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,15 +1,14 @@
 /*
 File: JobCard.cpp
-Description: Implementation file containing the method definitions of the
-             JobCard class, including constructors, getters, and setters
-             for job card attributes.
+Description: Implements the JobCard class which represents a technician’s job assignment in the Vehicle Service Management System.
+             Provides constructors, accessors, and mutators for job details such as ID, booking, service, technician,
+             assigned date, completion date, and job status.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
 
 #include <sstream>
 #include <stdexcept>
-#include "SerializedRecords.h"
 #include "JobCard.h"
 #include "Factory.h"
 #include "StringHelper.h"
@@ -19,18 +18,19 @@ int JobCard::m_uid = 0;
 
 /*
 Function: JobCard
-Description: Default constructor that initializes a new job card with
-             a unique ID and default values.
-Parameter: None
-Return type: Constructor
+Description: Default constructor that initializes a new job card with a unique ID,
+             null booking, null service, null technician, and default job status.
+Parameters:
+    - None
+Returns:
+    - A new JobCard object.
 */
 JobCard::JobCard()
     : m_id("JC" + std::to_string(++m_uid)),
     m_booking(nullptr),
     m_service(nullptr),
     m_technician(nullptr),
-    m_status(util::ServiceJobStatus()) {
-}
+    m_status(util::ServiceJobStatus()) {}
 
 /*
 Function: JobCard
@@ -67,8 +67,7 @@ JobCard::JobCard(const std::string& bookingId,
     m_technician(technician),
     m_assignedDate(assignedDate),
     m_status(status),
-    m_completionDate(completionDate) {
-}
+    m_completionDate(completionDate) {}
 
 /*
 Function: JobCard (parameterized constructor with ID)
@@ -354,41 +353,79 @@ void JobCard::setCompletionDate(const util::Timestamp& completionDate)
 
 /*
 Function: serialize
-Description: Serializes the JobCard object into a SerializedJobCard record.
+Description: Serializes the job card into a CSV-formatted string.
 Parameters:
     - None
 Returns:
-    - SerializedJobCard: Serialized representation of the job card
+    - std::string: Serialized job card record
 */
-SerializedJobCard JobCard::serialize() const
+std::string JobCard::serialize() const
 {
-    SerializedJobCard serialized = {};
-    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
-    strcpy_s(serialized.bookingId, sizeof(serialized.bookingId), m_bookingId.c_str());
-    strcpy_s(serialized.serviceId, sizeof(serialized.serviceId), m_serviceId.c_str());
-    strcpy_s(serialized.technicianId, sizeof(serialized.technicianId), m_technicianId.c_str());
-    serialized.assignedDate = m_assignedDate;
-    serialized.status = m_status;
-    serialized.completionDate = m_completionDate;
-    return serialized;
+    std::ostringstream serializedJobCard;
+    serializedJobCard << m_id << ','
+        << m_bookingId << ','
+        << m_serviceId << ','
+        << m_technicianId << ','
+        << m_assignedDate.toString() << ','
+        << util::getServiceJobStatusString(m_status) << ','
+        << m_completionDate.toString();
+    return serializedJobCard.str();
 }
 
 /*
 Function: deserialize
-Description: Deserializes a SerializedJobCard record into a JobCard object.
+Description: Deserializes a CSV-formatted string into a JobCard object.
 Parameters:
-    - serializedJobCard: const SerializedJobCard&, serialized job card record
+    - record: const std::string&, serialized job card record
 Returns:
     - JobCard*: Pointer to the deserialized JobCard object
+Throws:
+    - std::runtime_error if timestamp parsing fails
 */
-JobCard* JobCard::deserialize(const SerializedJobCard& serializedJobCard)
+JobCard* JobCard::deserialize(const std::string& record)
 {
+    std::string id, bookingId, serviceId, technicianId;
+    std::string assignedDateString, statusString, completionDateString;
+    std::istringstream serializedJobCard(record);
+    getline(serializedJobCard, id, ',');
+    getline(serializedJobCard, bookingId, ',');
+    getline(serializedJobCard, serviceId, ',');
+    getline(serializedJobCard, technicianId, ',');
+    getline(serializedJobCard, assignedDateString, ',');
+    getline(serializedJobCard, statusString, ',');
+    getline(serializedJobCard, completionDateString, ',');
+    util::Timestamp assignedDate;
+    util::Timestamp completionDate;
+    try
+    {
+        assignedDate = util::Timestamp::fromString(assignedDateString);
+        completionDate = util::Timestamp::fromString(completionDateString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid timestamp");
+    }
+    util::ServiceJobStatus status = util::getServiceJobStatus(statusString);
     return Factory::getObject<JobCard>(
-        serializedJobCard.id,
-        serializedJobCard.bookingId,
-        serializedJobCard.serviceId,
-        serializedJobCard.technicianId,
-        serializedJobCard.assignedDate,
-        serializedJobCard.status,
-        serializedJobCard.completionDate);
+        id,
+        bookingId,
+        serviceId,
+        technicianId,
+        assignedDate,
+        status,
+        completionDate
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for job card serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,BookingID,ServiceID,TechnicianID,AssignedDate,Status,CompletionDate")
+*/
+std::string JobCard::getHeaders()
+{
+    return "ID,BookingID,ServiceID,TechnicianID,AssignedDate,Status,CompletionDate";
 }

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

@@ -1,21 +1,19 @@
 /*
 File: JobCard.h
-Description: Header file declaring the JobCard class, which represents
-             a service job card containing booking, service, technician,
-             and status details.
+Description: Declares the JobCard class which represents a technician’s job assignment in the Vehicle Service Management System.
+             Each job card includes booking details, associated service, technician information, assigned and completion dates, and job status.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
 
 #pragma once
 #include <string>
-#include "Enums.h"
 #include "Timestamp.h"
+#include "Enums.h"
 
 class ServiceBooking;
 class Service;
 class User;
-struct SerializedJobCard;
 
 class JobCard
 {
@@ -31,6 +29,7 @@ private:
     util::Timestamp m_assignedDate;
     util::ServiceJobStatus m_status;
     util::Timestamp m_completionDate;
+
 public:
     JobCard();
     JobCard(const std::string& bookingId,
@@ -71,6 +70,7 @@ public:
     void setAssignedDate(const util::Timestamp& assignedDate);
     void setStatus(util::ServiceJobStatus status);
     void setCompletionDate(const util::Timestamp& completionDate);
-    SerializedJobCard serialize() const;
-    static JobCard* deserialize(const SerializedJobCard&);
+    std::string serialize() const;
+    static JobCard* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

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

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

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

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

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

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

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

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

@@ -6,10 +6,8 @@ Description: Implementation file containing the method definitions of the
 Author: Trenser
 Date:19-May-2026
 */
-
 #include <stdexcept>
 #include <sstream>
-#include "SerializedRecords.h"
 #include "ServiceBooking.h"
 #include "Service.h"
 #include "Enums.h"
@@ -26,12 +24,10 @@ Parameters: None
 Returns: A new ServiceBooking object.
 */
 ServiceBooking::ServiceBooking()
-    : m_id("SBK" + std::to_string(++m_uid)),
+    : m_id("SRV" + std::to_string(++m_uid)),
     m_customer(nullptr),
     m_assignedTechnician(nullptr),
-    m_status(util::ServiceJobStatus::PENDING),
-    m_discountPercentage(0.0) {
-}
+    m_discountPercentage(0.0) {}
 
 /*
 Function: ServiceBooking
@@ -45,6 +41,8 @@ Parameters:
     - vehicleNumber: Vehicle registration number.
     - vehicleBrand: Brand of the vehicle.
     - vehicleModel: Model of the vehicle.
+    - assignedTechnicianId: ID of the assigned technician.
+    - assignedTechnician: Name of the assigned technician.
     - discountPercentage: Discount applied to the booking.
 Returns:
     - A new ServiceBooking object.
@@ -60,7 +58,7 @@ ServiceBooking::ServiceBooking(
     const std::string& vehicleModel,
     double discountPercentage
 )
-    : m_id("SBK" + std::to_string(++m_uid)),
+    : m_id("SRV" + std::to_string(++m_uid)),
     m_status(status),
     m_services(services),
     m_customerId(customerId),
@@ -163,12 +161,6 @@ const util::Vector<std::string>& ServiceBooking::getServiceIDs() const
     return m_serviceIDs;
 }
 
-/*
-Function: getServices
-Description: Retrieves the services associated with the booking.
-Parameter: None
-Return type: const util::Map<std::string, Service*>&
-*/
 /*
 Function: getServices
 Description: Retrieves the services associated with the booking.
@@ -440,46 +432,84 @@ static util::Vector<std::string> getServiceIDsAsVector(const std::string& servic
 
 /*
 Function: serialize
-Description: Serializes the ServiceBooking object into a SerializedServiceBooking record.
+Description: Serializes the service booking into a CSV-formatted string.
 Parameters:
     - None
 Returns:
-    - SerializedServiceBooking: Serialized representation of the service booking
+    - std::string: Serialized booking record
 */
-SerializedServiceBooking ServiceBooking::serialize() const
+std::string ServiceBooking::serialize() const
 {
-    SerializedServiceBooking serialized = {};
-    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
-    strcpy_s(serialized.serviceIDs, sizeof(serialized.serviceIDs), getServiceIDsAsString(m_serviceIDs).c_str());
-    strcpy_s(serialized.customerId, sizeof(serialized.customerId), m_customerId.c_str());
-    strcpy_s(serialized.vehicleNumber, sizeof(serialized.vehicleNumber), m_vehicleNumber.c_str());
-    strcpy_s(serialized.vehicleBrand, sizeof(serialized.vehicleBrand), m_vehicleBrand.c_str());
-    strcpy_s(serialized.vehicleModel, sizeof(serialized.vehicleModel), m_vehicleModel.c_str());
-    strcpy_s(serialized.assignedTechnicianId, sizeof(serialized.assignedTechnicianId), m_assignedTechnicianId.c_str());
-    serialized.status = m_status;
-    serialized.discountPercentage = m_discountPercentage;
-    return serialized;
+    std::ostringstream serializedBooking;
+    serializedBooking << m_id << ','
+        << util::getServiceJobStatusString(m_status) << ','
+        << getServiceIDsAsString(m_serviceIDs) << ','
+        << m_customerId << ','
+        << m_vehicleNumber << ','
+        << m_vehicleBrand << ','
+        << m_vehicleModel << ','
+        << m_assignedTechnicianId << ','
+        << m_discountPercentage << ',';
+    return serializedBooking.str();
 }
 
 /*
 Function: deserialize
-Description: Deserializes a SerializedServiceBooking record into a ServiceBooking object.
+Description: Deserializes a CSV-formatted string into a ServiceBooking object.
 Parameters:
-    - serializedServiceBooking: const SerializedServiceBooking&, serialized service booking record
+    - record: const std::string&, serialized booking record
 Returns:
     - ServiceBooking*: Pointer to the deserialized ServiceBooking object
+Throws:
+    - std::runtime_error if discount percentage parsing fails
 */
-ServiceBooking* ServiceBooking::deserialize(const SerializedServiceBooking& serializedServiceBooking)
+ServiceBooking* ServiceBooking::deserialize(const std::string& record)
 {
-    util::Vector<std::string> serviceIDs = getServiceIDsAsVector(serializedServiceBooking.serviceIDs);
+    std::string id, customerId, vehicleNumber, vehicleBrand, vehicleModel, assignedTechnicianId;
+    std::string serviceJobStatusString, serviceIDsString, discountPercentageString;
+    double discountPercentage;
+    std::istringstream serializedBooking(record);
+    getline(serializedBooking, id, ',');
+    getline(serializedBooking, serviceJobStatusString, ',');
+    getline(serializedBooking, serviceIDsString, ',');
+    getline(serializedBooking, customerId, ',');
+    getline(serializedBooking, vehicleNumber, ',');
+    getline(serializedBooking, vehicleBrand, ',');
+    getline(serializedBooking, vehicleModel, ',');
+    getline(serializedBooking, assignedTechnicianId, ',');
+    getline(serializedBooking, discountPercentageString, ',');
+    util::Vector<std::string> serviceIDs = getServiceIDsAsVector(serviceIDsString);
+    try
+    {
+        discountPercentage = std::stod(discountPercentageString);
+    }
+    catch (...)
+    {
+        throw std::runtime_error("Invalid discount percentage");
+    }
+    util::ServiceJobStatus status = util::getServiceJobStatus(serviceJobStatusString);
     return Factory::getObject<ServiceBooking>(
-        serializedServiceBooking.id,
-        serializedServiceBooking.status,
+        id,
+        status,
         serviceIDs,
-        serializedServiceBooking.customerId,
-        serializedServiceBooking.vehicleNumber,
-        serializedServiceBooking.vehicleBrand,
-        serializedServiceBooking.vehicleModel,
-        serializedServiceBooking.assignedTechnicianId,
-        serializedServiceBooking.discountPercentage);
+        customerId,
+        vehicleNumber,
+        vehicleBrand,
+        vehicleModel,
+        assignedTechnicianId,
+        discountPercentage
+    );
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for service booking serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,Status,ServiceIDs,CustomerID,VehicleNumber,VehicleBrand,VehicleModel,AssignedTechnicianID,DiscountPercentage")
+*/
+std::string ServiceBooking::getHeaders()
+{
+    return "ID,Status,ServiceIDs,CustomerID,VehicleNumber,VehicleBrand,VehicleModel,AssignedTechnicianID,DiscountPercentage";
 }

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

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

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

@@ -8,7 +8,6 @@ Date: 19-May-2026
 */
 
 #include <sstream>
-#include "SerializedRecords.h"
 #include "User.h"
 #include "Notification.h"
 #include "Enums.h"
@@ -29,8 +28,7 @@ Returns:
 User::User()
     : m_id("USR" + std::to_string(++m_uid)),
     m_type(util::UserType::CUSTOMER),
-    m_status(util::State::ACTIVE) {
-}
+    m_status(util::State::ACTIVE) {}
 
 /*
 Function: User
@@ -53,8 +51,7 @@ User::User(const std::string& userName, const std::string& password, const std::
     m_phone(phone),
     m_email(email),
     m_type(role),
-    m_status(util::State::ACTIVE) {
-}
+    m_status(util::State::ACTIVE) {}
 
 /*
 Function: User (parameterized constructor with ID)
@@ -89,6 +86,23 @@ User::User(const std::string& userId, const std::string& userName, const std::st
     }
 }
 
+/*
+Function: ~User
+Description: Destructor that cleans up dynamically allocated notifications associated with the user.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+User::~User()
+{
+    auto values = m_notifications.getValues();
+    for (int index = 0; index < values.getSize(); index++)
+    {
+        delete values[index];
+    }
+}
+
 /*
 Function: getId
 Description: Retrieves the unique ID of the user.
@@ -155,6 +169,17 @@ const std::string& User::getEmail() const
     return m_email;
 }
 
+/*
+Function: getNotifications
+Description: Retrieves the map of notifications associated with the user.
+Returns:
+    - util::Map<std::string, Notification*>& representing the notifications.
+*/
+util::Map<std::string, Notification*>& User::getNotifications()
+{
+    return m_notifications;
+}
+
 /*
 Function: getUserType
 Description: Retrieves the role of the user.
@@ -255,6 +280,22 @@ void User::setEmail(const std::string& email)
     m_email = email;
 }
 
+/*
+Function: addNotification
+Description: Adds a new notification to the user’s notification map.
+Parameters:
+    - notification: Pointer to the Notification object.
+Returns:
+    - void
+*/
+void User::addNotification(Notification* notification)
+{
+    if (notification)
+    {
+        m_notifications.insert(notification->getId(), notification);
+    }
+}
+
 /*
 Function: setRole
 Description: Sets the role of the user.
@@ -283,43 +324,68 @@ void User::setState(util::State status)
 
 /*
 Function: serialize
-Description: Serializes the User object into a SerializedUser record.
+Description: Serializes the user into a CSV-formatted string.
 Parameters:
     - None
 Returns:
-    - SerializedUser: Serialized representation of the user
+    - std::string: Serialized user record
 */
-SerializedUser User::serialize() const
+std::string User::serialize() const
 {
-    SerializedUser serialized = {};
-    strcpy_s(serialized.id, sizeof(serialized.id), m_id.c_str());
-    strcpy_s(serialized.username, sizeof(serialized.username), m_userName.c_str());
-    strcpy_s(serialized.password, sizeof(serialized.password), m_password.c_str());
-    strcpy_s(serialized.name, sizeof(serialized.name), m_name.c_str());
-    strcpy_s(serialized.phone, sizeof(serialized.phone), m_phone.c_str());
-    strcpy_s(serialized.email, sizeof(serialized.email), m_email.c_str());
-    serialized.userType = m_type;
-    serialized.status = m_status;
-    return serialized;
+    std::ostringstream serializedUser;
+    serializedUser << m_id << ','
+        << m_userName << ','
+        << m_password << ','
+        << m_name << ','
+        << m_phone << ','
+        << m_email << ','
+        << util::getUserTypeString(m_type) << ','
+        << util::getStateString(m_status);
+    return serializedUser.str();
 }
 
 /*
 Function: deserialize
-Description: Deserializes a SerializedUser record into a User object.
+Description: Deserializes a CSV-formatted string into a User object.
 Parameters:
-    - serializedUser: const SerializedUser&, serialized user record
+    - record: const std::string&, serialized user record
 Returns:
     - User*: Pointer to the deserialized User object
 */
-User* User::deserialize(const SerializedUser& serializedUser)
+User* User::deserialize(const std::string& record)
 {
-    return Factory::getObject<User>(
-        serializedUser.id,
-        serializedUser.username,
-        serializedUser.password,
-        serializedUser.name,
-        serializedUser.phone,
-        serializedUser.email,
-        serializedUser.userType,
-        serializedUser.status);
+    std::string id, name, username, phone, password, email;
+    std::string userTypeString, stateString;
+    std::istringstream serializedUser(record);
+    getline(serializedUser, id, ',');
+    getline(serializedUser, username, ',');
+    getline(serializedUser, password, ',');
+    getline(serializedUser, name, ',');
+    getline(serializedUser, phone, ',');
+    getline(serializedUser, email, ',');
+    getline(serializedUser, userTypeString, ',');
+    getline(serializedUser, stateString);
+    util::UserType userType = util::getUserType(userTypeString);
+    util::State status = util::getState(stateString);
+    return Factory::getObject<User>(id,
+        username,
+        password,
+        name,
+        phone,
+        email,
+        userType,
+        status);
+}
+
+/*
+Function: getHeaders
+Description: Retrieves the CSV headers for user serialization.
+Parameters:
+    - None
+Returns:
+    - std::string: Header string ("ID,Username,Password,Name,Phone,Email,UserType,UserStatus")
+*/
+std::string User::getHeaders()
+{
+    return "ID,Username,Password,Name,Phone,Email,UserType,UserStatus";
 }

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

@@ -14,7 +14,6 @@ Date: 19-May-2026
 #include "Enums.h"
 
 class Notification;
-struct SerializedUser;
 
 class User : public Observer
 {
@@ -26,19 +25,21 @@ private:
     std::string m_name;
     std::string m_phone;
     std::string m_email;
+    util::Map<std::string, Notification*> m_notifications;
     util::UserType m_type;
     util::State m_status;
 public:
     User();
     User(const std::string& userName, const std::string& password, const std::string& name, const std::string& phone, const std::string& email, util::UserType role);
     User(const std::string& userId, const std::string& userName, const std::string& password, const std::string& name, const std::string& phone, const std::string& email, util::UserType role, util::State status);
-    ~User() = default;
+    ~User();
     const std::string& getId() const;
     const std::string& getUserName() const;
     const std::string& getPassword() const;
     const std::string& getName() const;
     const std::string& getPhone() const;
     const std::string& getEmail() const;
+    util::Map<std::string, Notification*>& getNotifications();
     util::UserType getUserType() const;
     util::State getState() const;
     void setId(const std::string& id);
@@ -47,8 +48,10 @@ public:
     void setName(const std::string& name);
     void setPhone(const std::string& phone);
     void setEmail(const std::string& email);
+    void addNotification(Notification* notification) override;
     void setRole(util::UserType role);
     void setState(util::State status);
-    SerializedUser serialize() const;
-    static User* deserialize(const SerializedUser& serializedUser);
+    std::string serialize() const;
+    static User* deserialize(const std::string&);
+    static std::string getHeaders();
 };

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

@@ -1,41 +1,16 @@
 /*
 File: AuthenticationManagementService.cpp
 Description: Implementation file containing the method definitions of the
-			 AuthenticationManagementService class, including logout and
-			 password change logic.
+			 AuthenticationManagementService class, including login, logout,
+			 password change, and retrieval of the authenticated user.
 Author: Trenser
 Date:19-May-2026
 */
-
 #include <stdexcept>
 #include "AuthenticationManagementService.h"
 #include "User.h"
-#include "Utility.h"
-#include "DataStoreLockGuard.h"
 
 User* AuthenticationManagementService::m_authenticatedUser = nullptr;
-bool AuthenticationManagementService::m_isAuthorized = false;
-EventManager AuthenticationManagementService::m_eventManager;
-HANDLE AuthenticationManagementService::m_accountDisabledEvent = NULL;
-HANDLE AuthenticationManagementService::m_notificationsAvailableEvent = NULL;
-
-
-/*
-Function: ensureAuthorization
-Description: Verifies that a user is currently authenticated before allowing
-			 access to a protected operation. Throws an exception if no
-			 authorized user session exists.
-Parameter: None
-Return type: void
-Throws: std::runtime_error - if the user is not authorized
-*/
-void AuthenticationManagementService::ensureAuthorization()
-{
-	if (!m_authenticatedUser || !m_isAuthorized)
-	{
-		throw std::runtime_error("You are not authorized to do this operation!");
-	}
-}
 
 /*
 Function: login
@@ -48,35 +23,16 @@ Return type: bool - true if login successful, false otherwise
 */
 bool AuthenticationManagementService::login(const std::string& username, const std::string& password)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUserMap = m_dataStore.getUsers();
-	int trackedUserMapSize = trackedUserMap.getSize();
-	for (int index = 0; index < trackedUserMapSize; index++)
+	util::Map<std::string, User*> users = m_dataStore.getUsers();
+	int usersMapSize = users.getSize();
+	for (int index = 0; index < usersMapSize; index++)
 	{
-		User* user = trackedUserMap.getValueAt(index).data;
+		User* user = users.getValueAt(index);
 		if (username == user->getUserName())
 		{
 			if (password == user->getPassword())
 			{
 				m_authenticatedUser = user;
-				m_isAuthorized = true;
-				m_eventManager.initialize(
-					user->getId(),
-					[]()
-					{
-						if (m_accountDisabledEvent)
-						{
-							AuthenticationManagementService::m_isAuthorized = false;
-							SetEvent(m_accountDisabledEvent);
-						}
-					},
-					[]()
-					{
-						if (m_notificationsAvailableEvent)
-						{
-							SetEvent(m_notificationsAvailableEvent);
-						}
-					});
 				return true;
 			}
 			return false;
@@ -105,11 +61,7 @@ Return type: void
 */
 void AuthenticationManagementService::logout()
 {
-	m_eventManager.shutdown();
 	m_authenticatedUser = nullptr;
-	m_isAuthorized = false;
-	m_accountDisabledEvent = NULL;
-	m_notificationsAvailableEvent = NULL;
 }
 
 /*
@@ -121,33 +73,9 @@ Return type: void
 */
 void AuthenticationManagementService::changePassword(const std::string& newPassword)
 {
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers();
 	if (m_authenticatedUser == nullptr)
 	{
 		throw std::runtime_error("There is no user currently logged in!");
 	}
-	int index = trackedUsersMap.find(m_authenticatedUser->getId());
-	if (index == -1)
-	{
-		throw std::runtime_error("User does not exist!\n");
-	}
 	m_authenticatedUser->setPassword(newPassword);
-	trackedUsersMap.getValueAt(index).state = RecordState::MODIFIED;
-	m_dataStore.saveUsers();
-}
-
-/*
-Function: registerEvents
-Description: Registers menu event handles used to notify the active
-			 menu of account disable and notification events.
-Parameter: HANDLE accountDisabledEvent - account disabled event handle
-		   HANDLE notificationAvailableEvent - notification event handle
-Return type: void
-*/
-void AuthenticationManagementService::registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent)
-{
-	m_accountDisabledEvent = accountDisabledEvent;
-	m_notificationsAvailableEvent = notificationAvailableEvent;
 }

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/services/AuthenticationManagementService.h

@@ -6,11 +6,8 @@ Description: Header file declaring the AuthenticationManagementService class, wh
 Author: Trenser
 Date:19-May-2026
 */
-
 #pragma once
 #include <string>
-#include <windows.h>
-#include "EventManager.h"
 #include "DataStore.h"
 
 class User;
@@ -19,17 +16,11 @@ class AuthenticationManagementService
 {
 private:
     static User* m_authenticatedUser;
-    static bool m_isAuthorized;
-    static EventManager m_eventManager;
-    static HANDLE m_accountDisabledEvent;
-    static HANDLE m_notificationsAvailableEvent;
     DataStore& m_dataStore;
 public:
     AuthenticationManagementService() : m_dataStore(DataStore::getInstance()) {}
-    static void ensureAuthorization();
     bool login(const std::string& username, const std::string& password);
     void logout();
     void changePassword(const std::string& newPassword);
     User* getAuthenticatedUser();
-    void registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent);
 };

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

@@ -7,71 +7,94 @@ Description: Implements the InventoryManagementService class, which manages inve
 Author: Trenser
 Date: 22-May-2026
 */
-
 #include <stdexcept>
 #include "Config.h"
 #include "Enums.h"
 #include "Factory.h"
+#include "FileManager.h"
 #include "InventoryItem.h"
 #include "InventoryManagementService.h"
-#include "AuthenticationManagementService.h"
 #include "Timestamp.h"
 #include "User.h"
 #include "Utility.h"
 #include "Vector.h"
-#include "DataStoreLockGuard.h"
-#include "EventManager.h"
 
 util::Map<std::string, User*> InventoryManagementService::m_observers{};
 
-/*
-Function: sendLowStockAlertsToAdmins (static helper)
-Description: Sends low stock alert notifications to all admin users for a given inventory item.
-Parameters:
-	- inventoryManagementService: InventoryManagementService&, service used to send notifications
-	- inventoryItem: const InventoryItem*, pointer to the low-stock inventory item
-	- adminUsers: const util::Vector<User*>&, list of admin users to notify
-Returns:
-	- None
-*/
+void InventoryManagementService::attach(User* user)
+{
+	if (user)
+	{
+		const std::string& userID = user->getId();
+		if (m_observers.find(userID) == -1)
+		{
+			m_observers[userID] = user;
+		}
+	}
+}
+
+void InventoryManagementService::detach(User* user)
+{
+	if (user)
+	{
+		const std::string& userID = user->getId();
+		if (m_observers.find(userID) != -1)
+		{
+			m_observers.remove(userID);
+		}
+	}
+}
+
+void InventoryManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
+{
+	if (user)
+	{
+		if (m_observers.find(user->getId()) != -1)
+		{
+			Notification* notification =
+				Factory::getObject<Notification>(
+					user->getId(),
+					user,
+					"InventoryManagementService: " + title,
+					message,
+					util::Timestamp()
+				);
+			if (notification)
+			{
+				user->addNotification(notification);
+			}
+			else
+			{
+				throw std::runtime_error("Failed to create notification");
+			}
+		}
+	}
+}
+
 static void sendLowStockAlertsToAdmins(InventoryManagementService& inventoryManagementService, const InventoryItem* inventoryItem, const util::Vector<User*>& adminUsers)
 {
 	int adminUsersSize = adminUsers.getSize();
 	for (int index = 0; index < adminUsersSize; index++)
 	{
-		std::string title = "Low Stock Alert";
-		std::string message = "The inventory item with ID " + inventoryItem->getId() + " has very low quantity in the inventory";
 		inventoryManagementService.sendNotification(
 			adminUsers[index],
-			title,
-			message
+			"Low Stock Alert",
+			"The inventory item with ID " + inventoryItem->getId() +
+			" has very low quantity in the inventory"
 			);
 	}
 }
 
-/*
-Function: sendLowStockAlerts
-Description: Sends alerts to user for inventory items with low stock
-Parameters:
-	- None
-Returns:
-	- None
-*/
 void InventoryManagementService::sendLowStockAlerts()
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInventoryItemsMap = m_dataStore.getInventoryItems();
-	auto& trackedUserMap = m_dataStore.getUsers();
-	if (trackedInventoryItemsMap.isEmpty())
-	{
-		return;
-	}
-	int inventoryItemsSize = trackedInventoryItemsMap.getSize();
-	int usersMapSize = trackedUserMap.getSize();
+	auto& inventoryItems = m_dataStore.getInventoryItems();
+	int inventoryItemsSize = inventoryItems.getSize();
+	auto& usersMap = m_dataStore.getUsers();
+	int usersMapSize = usersMap.getSize();
 	util::Vector<User*> adminUsers;
 	for (int index = 0; index < usersMapSize; index++)
 	{
-		User* user = trackedUserMap.getValueAt(index).data;
+		User* user = usersMap.getValueAt(index);
 		if (user->getUserType() == util::UserType::ADMIN)
 		{
 			adminUsers.push_back(user);
@@ -82,9 +105,9 @@ void InventoryManagementService::sendLowStockAlerts()
 	{
 		throw std::runtime_error("The system has no admins present!");
 	}
-	for (int index = 0; index < inventoryItemsSize; index++)
+	for (int index = 0; index <= inventoryItemsSize; index++)
 	{
-		InventoryItem* inventoryItem = trackedInventoryItemsMap.getValueAt(index).data;
+		InventoryItem* inventoryItem = inventoryItems.getValueAt(index);
 		if (inventoryItem && inventoryItem->getQuantity() < config::threshold::INVENTORY_LOW_STOCK_THRESHOLD)
 		{
 			sendLowStockAlertsToAdmins(*this, inventoryItem, adminUsers);
@@ -92,202 +115,92 @@ void InventoryManagementService::sendLowStockAlerts()
 	}
 }
 
-/*
-Function: addInventoryItem
-Description: Creates a new inventory item using the Factory and inserts it
-             into the DataStore.
-Parameter: const std::string& partName - name of the part
-           int quantity - initial quantity of the part
-           double price - price of the part
-Return type: void
-*/
-void InventoryManagementService::addInventoryItem(const std::string& partName, int quantity, double price)
-{
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
-    InventoryItem* newItem = Factory::getObject<InventoryItem>(partName, quantity, price);
-	trackedInventoryItemMap.insert(newItem->getId(), util::createNewRecord(newItem));
-	m_dataStore.saveInventoryItems();
-}
 
 /*
-Function: addInventoryItemStock
-Description: Increases the stock quantity of an existing inventory item.
-Parameter: const std::string& selectedItemId - ID of the inventory item
-           int quantity - quantity to add
-Return type: void
-*/
-void InventoryManagementService::addInventoryItemStock(const std::string& selectedItemId, int quantity)
-{
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
-	int index = trackedInventoryItemMap.find(selectedItemId);
-	if (index == -1)
-	{
-		throw std::runtime_error("Inventory update failed: Item ID '" + selectedItemId + "' not found.");
-	}
-	InventoryItem* item = trackedInventoryItemMap.getValueAt(index).data;
-	if (item == nullptr)
-	{
-		throw std::runtime_error("Inventory update failed. Item does not exist.\n");
-	}
-	int totalQuantity = item->getQuantity() + quantity;
-	item->setQuantity(totalQuantity);
-	trackedInventoryItemMap.getValueAt(index).state = RecordState::MODIFIED;
-	m_dataStore.saveInventoryItems();
-}
-
-/*
-Function: getInventoryItems
-Description: Retrieves all inventory items stored in the DataStore.
-Parameter: None
-Return type: util::Map<std::string, InventoryItem*>
-*/
-util::Map<std::string, InventoryItem*> InventoryManagementService::getInventoryItems()
-{
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
-	auto inventoryMap = util::getObjects(trackedInventoryItemMap);
-	return inventoryMap;
-}
-
-/*
-Function: removeInventoryItem
-Description: Marks an inventory item as inactive instead of deleting it.
-Parameter: const std::string& inventoryItemID - ID of the inventory item
-Return type: void
-*/
-void InventoryManagementService::removeInventoryItem(const std::string& inventoryItemID)
-{
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
-	int index = trackedInventoryItemMap.find(inventoryItemID);
-	if (index == -1)
-	{
-		throw std::runtime_error("Inventory removal failed: Item ID '" + inventoryItemID + "' not found.");
-	}
-	InventoryItem* item = trackedInventoryItemMap.getValueAt(index).data;
-	if (item == nullptr)
-	{
-		throw std::runtime_error("Inventory removal failed: Item ID does not exist.");
-	}
-	item->setState(util::State::INACTIVE);
-	trackedInventoryItemMap.getValueAt(index).state = RecordState::MODIFIED;
-	m_dataStore.saveInventoryItems();
-}
-
-/*
-Function: getInventoryItem
-Description: Retrieves a specific inventory item by its ID from the DataStore.
-Parameter: const std::string& inventoryItemID - ID of the inventory item
-Return type: InventoryItem*
-*/
-InventoryItem* InventoryManagementService::getInventoryItem(const std::string& inventoryItemID)
-{
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
-    int index = trackedInventoryItemMap.find(inventoryItemID);
-    if (index == -1)
-    {
-		return nullptr;
-    }
-	InventoryItem* inventoryItem = trackedInventoryItemMap.getValueAt(index).data;
-	if (inventoryItem == nullptr)
-	{
-		throw std::runtime_error("Item ID does not exist.");
-	}
-	return inventoryItem;
-}
-
-/*
-Function: attach
-Description: Adds a user to the observer list for receiving inventory notifications.
+Function: getObserverIDs
+Description: Retrieves the IDs of all observers currently attached to the
+			 InventoryManagementService.
 Parameters:
-	- user: User*, pointer to the user to be attached as an observer
-Returns:
 	- None
+Returns:
+	- util::Vector<std::string>: Vector of observer user IDs
 */
-void InventoryManagementService::attach(User* user)
+util::Vector<std::string> InventoryManagementService::getObserverIDs()
 {
-	DataStoreLockGuard lock(m_dataStore);
-	m_observers.clear();
-	m_observers = m_dataStore.getInventoryManagementObservers();
-	if (user)
+	util::Vector<std::string> observerIDs;
+	int numberOfObservers = m_observers.getSize();
+	for (int index = 0; index < numberOfObservers; index++)
 	{
-		const std::string& userID = user->getId();
-		if (m_observers.find(userID) == -1)
+		User* observer = m_observers.getValueAt(index);
+		if (observer)
 		{
-			m_observers[userID] = user;
+			observerIDs.push_back(observer->getId());
 		}
 	}
-	m_dataStore.saveInventoryManagementObservers(m_observers);
+	return observerIDs;
 }
 
 /*
-Function: detach
-Description: Removes a user from the observer list so they no longer receive inventory notifications.
+Function: loadInventoryItems
+Description: Loads inventory items from persistent storage into the datastore.
+			 Uses FileManager to deserialize inventory items from the configured file.
 Parameters:
-	- user: User*, pointer to the user to be detached from the observer list
-Returns:
 	- None
+Returns:
+	- void
 */
-void InventoryManagementService::detach(User* user)
+void InventoryManagementService::loadInventoryItems()
 {
-	DataStoreLockGuard lock(m_dataStore);
-	m_observers.clear();
-	m_observers = m_dataStore.getInventoryManagementObservers();
-	if (user)
+	util::FileManager<InventoryItem> inventoryItemFileManager(config::file::INVENTORYITEM_FILE);
+	auto& inventoryItems = m_dataStore.getInventoryItems();
+	auto inventoryItemsMap = inventoryItemFileManager.load();
+	int numberOfInventoryItems = inventoryItemsMap.getSize();
+	for (int index = 0; index < numberOfInventoryItems; index++)
 	{
-		const std::string& userID = user->getId();
-		if (m_observers.find(userID) != -1)
-		{
-			m_observers.remove(userID);
+		inventoryItems[inventoryItemsMap.getKeyAt(index)] = inventoryItemsMap.getValueAt(index);
 	}
-	}
-	m_dataStore.saveInventoryManagementObservers(m_observers);
 }
 
 /*
-Function: sendNotification
-Description: Sends a notification to a user if they are subscribed as an observer.
+Function: saveInventoryItems
+Description: Saves inventory items from the datastore to persistent storage.
+			 Uses FileManager to serialize inventory items into the configured file.
 Parameters:
-	- user: User*, pointer to the user receiving the notification
-	- title: std::string, title of the notification
-	- message: std::string, body/content of the notification
-Returns:
 	- None
-Throws:
-	- std::runtime_error if notification creation fails
+Returns:
+	- void
 */
-void InventoryManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
+void InventoryManagementService::saveInventoryItems()
 {
-	if (!user)
-	{
-		return;
-	}
-	DataStoreLockGuard lock(m_dataStore);
-	m_observers = m_dataStore.getInventoryManagementObservers();
-	if (m_observers.find(user->getId()) == -1)
-	{
-		return;
-	}
-	auto& trackedNotificationsMap = m_dataStore.getNotifications();
-	Notification* notification = Factory::getObject<Notification>(
-		user->getId(),
-		title,
-		message,
-		util::Timestamp());
-	if (!notification)
-	{
-		throw std::runtime_error("Failed to create notification");
-	}
-	trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
-	m_dataStore.saveNotifications();
-	EventManager::sendNotificationAvailableEvent(user->getId());
+	util::FileManager<InventoryItem> inventoryItemFileManager(config::file::INVENTORYITEM_FILE);
+	auto& inventoryItems = m_dataStore.getInventoryItems();
+	inventoryItemFileManager.save(inventoryItems);
 }
 
+/*
+Function: loadObservers
+Description: Loads observer IDs from persistent storage and attaches corresponding
+			 users as observers to the InventoryManagementService.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void InventoryManagementService::loadObservers()
+{
+	util::loadObservers(config::file::INVENTORYMANAGEMENTOBSERVERS, this, m_dataStore);
+}
+
+/*
+Function: saveObservers
+Description: Saves the current observer IDs of the InventoryManagementService
+			 to persistent storage for future retrieval.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void InventoryManagementService::saveObservers()
+{
+	util::saveObservers(config::file::INVENTORYMANAGEMENTOBSERVERS, this);
+}

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

@@ -1,10 +1,9 @@
 /*
 File: InventoryManagementService.h
-Description: Header file declaring the InventoryManagementService class,
-             which manages inventory items, stock updates, and notifications
-             related to low stock alerts. Inherits from NotificationManagementService.
+Description: Declares the InventoryManagementService class which manages inventory operations in the Vehicle Service Management System.
+             Provides functionality to retrieve, add, and remove inventory items, send low stock alerts, and handle notifications using the Observer pattern.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
 
 #pragma once
@@ -21,15 +20,19 @@ class InventoryManagementService : public NotificationManagementService
 private:
     DataStore& m_dataStore;
     static util::Map<std::string, User*> m_observers;
+    util::Vector<std::string> getObserverIDs() override;
 public:
     InventoryManagementService() : m_dataStore(DataStore::getInstance()) {}
     util::Map<std::string, InventoryItem*> getInventoryItems();
     InventoryItem* getInventoryItem(const std::string& inventoryItemID);
     void addInventoryItem(const std::string& partName, int quantity, double price);
     void removeInventoryItem(const std::string& inventoryItemID);
-    void addInventoryItemStock(const std::string& selectedItemId, int quantity);
     void sendLowStockAlerts();
     void sendNotification(User* user, const std::string& title, const std::string& message) override;
     void attach(User* user) override;
     void detach(User* user) override;
+    void loadInventoryItems();
+    void saveInventoryItems();
+    void loadObservers();
+    void saveObservers();
 };

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

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

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

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

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

@@ -11,19 +11,14 @@ Date: 20-May-2026
 #include "Config.h"
 #include "Enums.h"
 #include "Factory.h"
-#include "InventoryItem.h"
+#include "FileManager.h"
 #include "Invoice.h"
-#include "JobCard.h"
 #include "PaymentManagementService.h"
-#include "AuthenticationManagementService.h"
-#include "DataStoreLockGuard.h"
-#include "Service.h"
 #include "ServiceBooking.h"
 #include "Timestamp.h"
 #include "User.h"
 #include "Utility.h"
-#include "DataStoreLockGuard.h"
-#include "EventManager.h"
+
 
 util::Map<std::string, User*> PaymentManagementService::m_observers{};
 
@@ -37,9 +32,6 @@ Returns:
 */
 void PaymentManagementService::attach(User* user)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	m_observers.clear();
-	m_observers = m_dataStore.getPaymentManagementObservers();
 	if (user)
 	{
 		const std::string& userID = user->getId();
@@ -48,7 +40,6 @@ void PaymentManagementService::attach(User* user)
 			m_observers[userID] = user;
 		}
 	}
-	m_dataStore.savePaymentManagementObservers(m_observers);
 }
 
 /*
@@ -61,9 +52,6 @@ Returns:
 */
 void PaymentManagementService::detach(User* user)
 {
-	DataStoreLockGuard lock(m_dataStore);
-	m_observers.clear();
-	m_observers = m_dataStore.getPaymentManagementObservers();
 	if (user)
 	{
 		const std::string& userID = user->getId();
@@ -72,7 +60,6 @@ void PaymentManagementService::detach(User* user)
 			m_observers.remove(userID);
 		}
 	}
-	m_dataStore.savePaymentManagementObservers(m_observers);
 }
 
 /*
@@ -89,29 +76,28 @@ Throws:
 */
 void PaymentManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
 {
-	if (!user)
+	if (user)
 	{
-		return;
-	}
-	DataStoreLockGuard lock(m_dataStore);
-	m_observers = m_dataStore.getPaymentManagementObservers();
-	if (m_observers.find(user->getId()) == -1)
+		if (m_observers.find(user->getId()) != -1)
 		{
-		return;
-	}
-	auto& trackedNotificationsMap = m_dataStore.getNotifications();
-	Notification* notification = Factory::getObject<Notification>(
+			Notification* notification =
+				Factory::getObject<Notification>(
 					user->getId(),
-		title,
+					user,
+					"PaymentManagementService: " + title,
 					message,
-		util::Timestamp());
-	if (!notification)
+					util::Timestamp()
+				);
+			if (notification)
+			{
+				user->addNotification(notification);
+			}
+			else
 			{
 				throw std::runtime_error("Failed to create notification");
 			}
-	trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
-	m_dataStore.saveNotifications();
-	EventManager::sendNotificationAvailableEvent(user->getId());
+		}
+	}
 }
 
 /*
@@ -125,12 +111,11 @@ Returns:
 */
 void PaymentManagementService::sendPaymentReminders()
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedInvoicesMap = m_dataStore.getInvoices();
-	int invoicesMapSize = trackedInvoicesMap.getSize();
+	auto& invoicesMap = m_dataStore.getInvoices();
+	int invoicesMapSize = invoicesMap.getSize();
 	for (int index = 0; index < invoicesMapSize; index++)
 	{
-		const Invoice* invoice = trackedInvoicesMap.getValueAt(index).data;
+		const Invoice* invoice = invoicesMap.getValueAt(index);
 		if (invoice && invoice->getStatus() == util::PaymentStatus::PENDING)
 		{
 			util::Timestamp invoiceCreationTimestamp = invoice->getInvoiceDate();
@@ -143,9 +128,9 @@ void PaymentManagementService::sendPaymentReminders()
 					User* customer = serviceBooking->getCustomer();
 					if (customer)
 					{
-						std::string title = "Payment Reminder";
-						std::string message = "Your payment for Invoice ID " + invoice->getId() + " is still pending. Please complete the payment.";
-						sendNotification(customer, title, message);
+						sendNotification(customer,
+							"Payment Reminder",
+							"Your payment for Invoice ID " + invoice->getId() + " is still pending.Please complete the payment." + invoice->getId());
 					}
 				}
 			}
@@ -154,192 +139,118 @@ void PaymentManagementService::sendPaymentReminders()
 }
 
 /*
-Function: createInventoryItemsMap (static helper)
-Description: Builds a map of inventory items required for a given service and adds them to the booking’s inventory map.
+Function: getObserverIDs
+Description: Retrieves the IDs of all observers currently attached to the
+             PaymentManagementService.
 Parameters:
-	- completeInventoryItemMapOfBooking: util::Map<std::string, InventoryItem*>&, map to store inventory items for the booking
-	- currentService: const Service*, pointer to the current service
+    - None
 Returns:
-	- void
+    - util::Vector<std::string>: Vector of observer user IDs
 */
-static void createInventoryItemsMap(util::Map<std::string, InventoryItem*>& completeInventoryItemMapOfBooking, const Service* currentService)
+util::Vector<std::string> PaymentManagementService::getObserverIDs()
 {
-	auto& currentRequiredInventoryItems = currentService->getRequiredInventoryItems();
-	for (int iterator = 0; iterator < currentRequiredInventoryItems.getSize(); iterator++)
+	util::Vector<std::string> observerIDs;
+	int numberOfObservers = m_observers.getSize();
+	for (int index = 0; index < numberOfObservers; index++)
 	{
-		auto& currentRequiredInventoryItem = currentRequiredInventoryItems.getValueAt(iterator);
-		completeInventoryItemMapOfBooking.insert(currentRequiredInventoryItem->getId(), currentRequiredInventoryItem);
+		User* observer = m_observers.getValueAt(index);
+		if (observer)
+		{
+			observerIDs.push_back(observer->getId());
 		}
+	}
+	return observerIDs;
 }
 
 /*
-Function: generateInvoice
-Description: Generates an invoice for a completed service booking.
-			 Validates that all job cards are completed, calculates labor and parts cost, applies discount,
-			 and stores the invoice in the datastore.
+Function: loadInvoices
+Description: Loads invoices from persistent storage into the datastore.
+             Validates associated service bookings and inventory parts before
+             attaching them to each invoice. Throws exceptions if invalid IDs
+             are encountered.
 Parameters:
-	- booking: ServiceBooking*, pointer to the service booking
+    - None
 Returns:
     - void
 Throws:
-	- std::runtime_error if booking is null or job cards are incomplete
+    - std::runtime_error if a booking ID or part ID is invalid
 */
-void PaymentManagementService::generateInvoice(ServiceBooking* booking)
+void PaymentManagementService::loadInvoices()
 {
-	DataStoreLockGuard lock(m_dataStore);
-	if (!booking)
+    util::FileManager<Invoice> invoiceFileManager(config::file::INVOICE_FILE);
+    auto& invoices = m_dataStore.getInvoices();
+    auto& serviceBookings = m_dataStore.getServiceBookings();
+    auto& inventoryItems = m_dataStore.getInventoryItems();
+    auto invoicesMap = invoiceFileManager.load();
+    for (int invoiceIndex = 0; invoiceIndex < invoicesMap.getSize(); invoiceIndex++)
     {
-		throw std::runtime_error("Invoice generation failed: booking is null.");
-	}
-	double totalLaborCost = 0, totalPartsCost = 0, totalServiceCost = 0;
-	double discountPercentage = booking->getDiscountPercentage();
-	std::string bookingID = booking->getId();
-	util::Map<std::string, Service*> servicesInTheBookedService = booking->getServices();
-	util::Map<std::string, InventoryItem*> completeInventoryItemMapOfBooking;
-	auto& currentTrackedJobCards = m_dataStore.getJobCards();
-	for (int iterator = 0; iterator < currentTrackedJobCards.getSize(); iterator++)
+        Invoice* invoice = invoicesMap.getValueAt(invoiceIndex);
+        int bookingIndex = serviceBookings.find(invoice->getBookingId());
+        if (bookingIndex == -1)
         {
-		JobCard* currentJobCard = currentTrackedJobCards.getValueAt(iterator).data;
-		util::ServiceJobStatus currentJobCardStatus = currentJobCard->getStatus();
-		if (currentJobCard->getBookingId() == bookingID && currentJobCardStatus != util::ServiceJobStatus::CANCELLED && currentJobCardStatus != util::ServiceJobStatus::COMPLETED)
+            throw std::runtime_error("Invalid Booking ID");
+        }
+        ServiceBooking* booking = serviceBookings.getValueAt(bookingIndex);
+        invoice->setBooking(booking);
+        util::Map<std::string, InventoryItem*> invoiceParts;
+        auto& partIDs = invoice->getPartIDs();
+        for (int partIndex = 0; partIndex < partIDs.getSize(); partIndex++)
         {
-			throw std::runtime_error("Invoice generation failed: Not all job cards are completed for booking '" + bookingID + "'.");
-		}
-	}
-	for (int iterator = 0; iterator < servicesInTheBookedService.getSize(); iterator++)
+            const std::string& partID = partIDs[partIndex];
+            int inventoryIndex = inventoryItems.find(partID);
+            if (inventoryIndex == -1)
             {
-		Service* currentService = servicesInTheBookedService.getValueAt(iterator);
-		if (currentService)
-		{
-			createInventoryItemsMap(completeInventoryItemMapOfBooking, currentService);
-			totalLaborCost += currentService->getLaborCost();
-			totalPartsCost += util::calculatePartsCost(currentService);
+                throw std::runtime_error("Invalid Part ID");
             }
+            invoiceParts[partID] = inventoryItems.getValueAt(inventoryIndex);
+        }
+        invoice->setParts(invoiceParts);
+        invoices[invoice->getId()] = invoice;
     }
-	totalServiceCost = totalLaborCost + totalPartsCost;
-	totalServiceCost -= (totalServiceCost * (discountPercentage / 100));
-	Invoice* invoice = Factory::getObject<Invoice>(bookingID, booking, util::Timestamp(), totalLaborCost, completeInventoryItemMapOfBooking, totalPartsCost, discountPercentage, totalServiceCost, util::Timestamp(), util::PaymentMode::NOTSET, util::PaymentStatus::PENDING);
-	auto& currentTrackedInvoices = m_dataStore.getInvoices();
-	currentTrackedInvoices.insert(invoice->getId(), util::createNewRecord(invoice));
-	m_dataStore.saveInvoices();
 }
 
 /*
-Function: getInvoices
-Description: Retrieves all invoices associated with a specific customer.
+Function: saveInvoices
+Description: Saves invoices from the datastore to persistent storage.
+             Uses FileManager to serialize invoices into the configured file.
 Parameters:
-	- customerID: std::string, ID of the customer
+    - None
 Returns:
-	- util::Map<std::string, Invoice*> containing the customer’s invoices
+    - void
 */
-util::Map<std::string, Invoice*> PaymentManagementService::getInvoices(const std::string& customerID)
+void PaymentManagementService::saveInvoices()
 {
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& currentTrackedInvoices = m_dataStore.getInvoices();
-	util::Map<std::string, Invoice*> currentUserInvoices;
-	for (int iterator = 0; iterator < currentTrackedInvoices.getSize(); iterator++)
-	{
-		Invoice* currentInvoice = currentTrackedInvoices.getValueAt(iterator).data;
-		if (currentInvoice->getBooking()->getCustomerId() == customerID)
-		{
-			currentUserInvoices.insert(currentInvoice->getId(), currentInvoice);
-		}
-	}
-	return currentUserInvoices;
+    util::FileManager<Invoice> invoiceFileManager(config::file::INVOICE_FILE);
+    auto& invoices = m_dataStore.getInvoices();
+    invoiceFileManager.save(invoices);
 }
 
 /*
-Function: completePayment
-Description: Completes payment for a specific invoice. Updates payment method, date, and status,
-			 then sends a notification to the customer.
+Function: loadObservers
+Description: Loads observer IDs from persistent storage and attaches corresponding
+             users as observers to the PaymentManagementService.
 Parameters:
-	- invoiceID: std::string, ID of the invoice
-	- paymentMode: util::PaymentMode, mode of payment (e.g., ONLINE, OFFLINE)
+    - None
 Returns:
     - void
 Throws:
-	- std::runtime_error if the invoice ID is invalid
+    - std::runtime_error if an observer ID is invalid (not found in datastore)
 */
-void PaymentManagementService::completePayment(const std::string& invoiceID, util::PaymentMode paymentMode)
+void PaymentManagementService::loadObservers()
 {
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& currentTrackedInvoices = m_dataStore.getInvoices();
-	int invoiceIndex = currentTrackedInvoices.find(invoiceID);
-	if (invoiceIndex != -1)
-	{
-		auto& trackedInvoice = currentTrackedInvoices.getValueAt(invoiceIndex);
-		Invoice* invoice = trackedInvoice.data;
-		if (invoice && invoice->getStatus() != util::PaymentStatus::PAID)
-		{
-			User* currentUser = invoice->getBooking()->getCustomer();
-			invoice->setPaymentMethod(paymentMode);
-			invoice->setPaymentDate(util::Timestamp());
-			invoice->setStatus(util::PaymentStatus::PAID);
-			std::string title, message;
-			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();
+    util::loadObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this, m_dataStore);
 }
 
 /*
-Function: getAllInvoices
-Description: Provides access to all invoices stored in the data store.
+Function: saveObservers
+Description: Saves the current observer IDs of the PaymentManagementService
+             to persistent storage for future retrieval.
 Parameters:
-	- none
-Returns:
-	- util::Map<std::string, Invoice*>: Map of invoice IDs to invoice objects
-*/
-util::Map<std::string, Invoice*> PaymentManagementService::getAllInvoices()
-{
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	util::Map<std::string, Invoice*> invoices;
-	invoices = util::getObjects(m_dataStore.getInvoices());
-	return invoices;
-}
-
-/*
-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
+    - None
 Returns:
     - void
-Throws:
-	- std::runtime_error if the invoice ID is invalid
 */
-void PaymentManagementService::confirmPayment(const std::string& invoiceID)
+void PaymentManagementService::saveObservers()
 {
-    AuthenticationManagementService::ensureAuthorization();
-	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.");
-	}
-	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();
+    util::saveObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this);
 }

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

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

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

@@ -6,7 +6,6 @@ Description: Header file declaring the ServiceManagementService class, which man
 Author: Trenser
 Date:19-May-2026
 */
-
 #pragma once
 #include <string>
 #include "Map.h"
@@ -23,6 +22,7 @@ class ServiceManagementService : public NotificationManagementService
 private:
     DataStore& m_dataStore;
     static util::Map<std::string, User*> m_observers;
+    util::Vector<std::string> getObserverIDs() override;
 public:
     ServiceManagementService() : m_dataStore(DataStore::getInstance()) {}
     util::Map<std::string, Service*> getServices();
@@ -31,18 +31,26 @@ public:
     void purchaseComboPackage(const std::string& comboPackageID, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel);
     util::Map<std::string, ServiceBooking*> getServiceBookings();
     util::Map<std::string, ServiceBooking*> getServiceBookings(const std::string& customerID);
-    ServiceBooking* getServiceBooking(const std::string& serviceID);
     void createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID);
     void createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost);
     void removeService(const std::string& serviceID);
-    void removeServiceBooking(const std::string& bookingID);
     util::Map<std::string, JobCard*> getJobCards(const std::string& technicianID);
-    void updateJobStatus(const std::string& jobID);
+    void completeJob(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);
+    void createComboPackage(const std::string& name, const util::Vector<std::string>& serviceIDs, double discountPercentage);
     void removeComboPackage(const std::string& comboPackageID);
     void sendNotification(User* user, const std::string& title, const std::string& message) override;
     void attach(User* user) override;
     void detach(User* user) override;
+    void loadServices();
+    void saveServices();
+    void loadComboPackages();
+    void saveComboPackages();
+    void loadServiceBookings();
+    void saveServiceBookings();
+    void loadJobCards();
+    void saveJobCards();
+    void loadObservers();
+    void saveObservers();
 };

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

@@ -6,24 +6,19 @@ Description: Implementation file containing the method definitions of the
 Author: Trenser
 Date:19-May-2026
 */
-
 #include <stdexcept>
 #include "Config.h"
 #include "Enums.h"
 #include "Factory.h"
+#include "FileManager.h"
 #include "InventoryManagementService.h"
 #include "Notification.h"
 #include "PaymentManagementService.h"
 #include "ServiceManagementService.h"
-#include "AuthenticationManagementService.h"
 #include "User.h"
 #include "UserManagementService.h"
 #include "Vector.h"
-#include "Validator.h"
-#include "Utility.h"
-#include "TrackedRecord.h"
-#include "DataStoreLockGuard.h"
-#include "EventManager.h"
+
 
 /*
 Function: ensureAdminExists
@@ -35,13 +30,12 @@ Return type: void
 */
 void UserManagementService::ensureAdminExists()
 {
-	DataStoreLockGuard lock(m_dataStore);
 	auto& usersMap = m_dataStore.getUsers();
 	int usersMapSize = usersMap.getSize();
 	bool isAdminFound = false;
 	for (int index = 0; index < usersMapSize; index++)
 	{
-		User* user = usersMap.getValueAt(index).data;
+		User* user = usersMap.getValueAt(index);
 		if (user && user->getUserType() == util::UserType::ADMIN)
 		{
 			isAdminFound = true;
@@ -78,30 +72,25 @@ void UserManagementService::createUser(const std::string& username, const std::s
 	InventoryManagementService inventoryManagementService;
 	PaymentManagementService paymentManagementService;
 	ServiceManagementService serviceManagementService;
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	auto usersMap = util::getObjects(trackedUsersMap);
-	if (util::isUsernameDuplicate(username, usersMap))
+	auto& usersMap = m_dataStore.getUsers();
+	int index = usersMap.findIf(
+		[&](const std::string&, User* user)
+		{
+			return user->getUserName() == username;
+		}
+	);
+	if (index != -1)
 	{
 		throw std::runtime_error("Username already exists");
 	}
-	if (util::isEmailDuplicate(email, usersMap))
-	{
-		throw std::runtime_error("Email already exists");
-	}
-	if (util::isPhoneDuplicate(phone, usersMap))
-	{
-		throw std::runtime_error("Phone already exists");
-	}
 	User* newUser = Factory::getObject<User>(username, password, name, phone, email, type);
-	trackedUsersMap.insert(newUser->getId(), util::createNewRecord(newUser));
+	usersMap.insert(newUser->getId(), newUser);
 	paymentManagementService.attach(newUser);
 	serviceManagementService.attach(newUser);
 	if (newUser->getUserType() == util::UserType::ADMIN)
 	{
 		inventoryManagementService.attach(newUser);
 	}
-	m_dataStore.saveUsers();
 }
 
 /*
@@ -115,40 +104,15 @@ Return type: void
 */
 void UserManagementService::updateUserDetails(const std::string& userID, const std::string& email, const std::string& phone)
 {
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	auto usersMap = util::getObjects(trackedUsersMap);
-	int index = trackedUsersMap.find(userID);
+	auto& usersMap = m_dataStore.getUsers();
+	int index = usersMap.find(userID);
 	if (index == -1)
 	{
-		throw std::runtime_error("User does not exist!\n");
-	}
-	User* user = trackedUsersMap.getValueAt(index).data;
-	bool isModified = false;
-	if (email != user->getEmail())
-	{
-		if (util::isEmailDuplicate(email, usersMap))
-		{
-			throw std::runtime_error("Email already exists!\n");
+		throw std::runtime_error("User does not exist!");
 	}
+	User* user = usersMap.getValueAt(index);
 	user->setEmail(email);
-		isModified = true;
-	}
-	if (phone != user->getPhone())
-	{
-		if (util::isPhoneDuplicate(phone, usersMap))
-		{
-			throw std::runtime_error("Phone number already exists!\n");
-		}
 	user->setPhone(phone);
-		isModified = true;
-	}
-	if (isModified)
-	{
-		trackedUsersMap.getValueAt(index).state = RecordState::MODIFIED;
-		m_dataStore.saveUsers();
-	}
 }
 
 /*
@@ -163,26 +127,20 @@ Throws:
 */
 util::Vector<Notification*> UserManagementService::getUserNotifications(const std::string& userID)
 {
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers(); 
-	if (trackedUsersMap.find(userID) == -1)
+	auto& usersMap = m_dataStore.getUsers();
+	if (usersMap.find(userID) == -1)
 	{
 		throw std::runtime_error("No user found with given UserID");
 	}
-	User* user = trackedUsersMap[userID].data;
+	User* user = usersMap[userID];
 	if (user)
 	{
-		auto& trackedNotificationMap = m_dataStore.getNotifications();
-		int numberOfNotifications = trackedNotificationMap.getSize();
+		auto& notifications = user->getNotifications();
+		int numberOfNotifications = notifications.getSize();
 		util::Vector<Notification*> notificationsVector;
 		for (int index = 0; index < numberOfNotifications; index++)
 		{
-			Notification* notification = trackedNotificationMap.getValueAt(index).data;
-			if (notification->getRecipientUserId() == userID && notification->getState() == util::State::ACTIVE)
-			{
-				notificationsVector.push_back(notification);
-			}
+		    notificationsVector.push_back(notifications.getValueAt(index));
 		}
 		return notificationsVector;
 	}
@@ -194,144 +152,95 @@ util::Vector<Notification*> UserManagementService::getUserNotifications(const st
 
 /*
 Function: deleteNotification
-Description: Marks a specific notification associated with a given user
-			 as inactive.
+Description: Deletes a specific notification associated with a given user ID.
 Parameters:
 	- notificationID: The unique ID of the notification to be deleted.
 	- userID: The unique ID of the user whose notification is to be deleted.
 Returns:
 	- void
 Throws:
-	- std::runtime_error if no user is found with the given UserID or
-	  if no notification is found with the given NotificationID.
+	- std::runtime_error if no user is found with the given UserID or if no notification is found with the given NotificationID.
 */
 void UserManagementService::deleteNotification(const std::string& notificationID, const std::string& userID)
 {
-    AuthenticationManagementService::ensureAuthorization();
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	auto& trackedNotificationsMap = m_dataStore.getNotifications();
-	int userIndex = trackedUsersMap.find(userID);
-	if (userIndex == -1)
+	auto& usersMap = m_dataStore.getUsers();
+	if (usersMap.find(userID) == -1)
 	{
 		throw std::runtime_error("No user found with given UserID");
 	}
-	int notificationIndex = trackedNotificationsMap.find(notificationID);
-	if (notificationIndex == -1)
+	User* user = usersMap[userID];
+	auto& notifications = user->getNotifications();
+	if (notifications.find(notificationID) == -1)
 	{
 		throw std::runtime_error("No notification found with given NotificationID");
 	}
-	Notification* notification = trackedNotificationsMap.getValueAt(notificationIndex).data;
-	if (notification->getRecipientUserId() == userID)
-	{
-		notification->setState(util::State::INACTIVE);
-		trackedNotificationsMap.getValueAt(notificationIndex).state = RecordState::MODIFIED;
-		m_dataStore.saveNotifications();
-	}
+	notifications.remove(notificationID);
 }
 
 /*
-Function: getUsers
-Description: Retrieves all users stored in the DataStore.
-Parameter: None
-Return type: util::Map<std::string, User*>
-*/
-util::Map<std::string, User*> UserManagementService::getUsers()
-{
-	DataStoreLockGuard lock(m_dataStore);
-	auto users = util::getObjects(m_dataStore.getUsers());
-	return users;
-}
-
-/*
-Function: getUser
-Description: Retrieves a specific user by ID from the DataStore.
-Parameter: const std::string& userID - ID of the user
-Return type: User*
-*/
-User* UserManagementService::getUser(const std::string& userID)
-{
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	int index = trackedUsersMap.find(userID);
-	if (index != -1)
-	{
-		return trackedUsersMap.getValueAt(index).data;
-	}
-	return nullptr;
-}
-
-/*
-Function: removeUser
-Description: Marks a user as inactive in the DataStore instead of deleting them.
-Parameter: const std::string& userID - ID of the user to remove
-Return type: void
-*/
-void UserManagementService::removeUser(const std::string& userID)
-{
-    AuthenticationManagementService::ensureAuthorization();
-	InventoryManagementService inventoryManagementService;
-	PaymentManagementService paymentManagementService;
-	ServiceManagementService serviceManagementService;
-	std::string removedUserID;
-	{
-		DataStoreLockGuard lock(m_dataStore);
-		auto& trackedUsersMap = m_dataStore.getUsers();
-		int index = trackedUsersMap.find(userID);
-		if (index != -1)
-		{
-			User* user = trackedUsersMap.getValueAt(index).data;
-			if (user != nullptr)
-			{
-				if (user->getUserType() == util::UserType::CUSTOMER)
-				{
-					serviceManagementService.cancelCustomerServiceBookings(userID);
-				}
-				if (user->getUserType() == util::UserType::TECHNICIAN)
-				{
-					serviceManagementService.cancelTechnicianJobs(userID);
-				}
-				inventoryManagementService.detach(user);
-				paymentManagementService.detach(user);
-				serviceManagementService.detach(user);
-				user->setState(util::State::INACTIVE);
-				trackedUsersMap.getValueAt(index).state = RecordState::MODIFIED;
-				removedUserID = user->getId();
-				m_dataStore.saveUsers();
-			}
-		}
-	}
-	if (!removedUserID.empty())
-	{
-		EventManager::sendUserDisabledEvent(removedUserID);
-	}
-}
-
-/*
-Function: getUsers
-Description: Retrieves all active users of the specified type from
-			 the DataStore.
+Function: loadUsers
+Description: Loads users and notifications from persistent storage into the datastore.
+             Validates that each notification’s recipient exists and attaches the
+             notification to the corresponding user.
 Parameters:
-	- type: The user type to filter by
-			(ADMIN, CUSTOMER, or TECHNICIAN).
+    - None
 Returns:
-	- util::Map<std::string, User*>:
-	  Collection of active users matching the specified type,
-	  keyed by user ID.
+    - void
+Throws:
+    - std::runtime_error if a notification recipient user ID is invalid
 */
-util::Map<std::string, User*> UserManagementService::getUsers(util::UserType type) 
+void UserManagementService::loadUsers()
 {
-	DataStoreLockGuard lock(m_dataStore);
-	auto& trackedUsersMap = m_dataStore.getUsers();
-	util::Map<std::string, User*> currentUsers = util::getObjects(trackedUsersMap);
-	util::Map<std::string, User*> filteredUsersMap;
-	for (int index = 0; index < currentUsers.getSize(); index++)
+    util::FileManager<User> userFileManager(config::file::USER_FILE);
+    util::FileManager<Notification> notificationFileManager(config::file::NOTIFICATION_FILE);
+    auto& users = m_dataStore.getUsers();
+    auto usersMap = userFileManager.load();
+    auto notificationsMap = notificationFileManager.load();
+    int numberOfUsers = usersMap.getSize();
+    int numberOfNotifications = notificationsMap.getSize();
+    for (int index = 0; index < numberOfUsers; index++)
     {
-		User* currentUser = currentUsers.getValueAt(index);
-		if (currentUser && currentUser->getState() == util::State::ACTIVE && currentUser->getUserType() == type)
+        users[usersMap.getKeyAt(index)] = usersMap.getValueAt(index);
+    }
+    for (int index = 0; index < numberOfNotifications; index++)
     {
-			filteredUsersMap.insert(currentUser->getId(), currentUser);
+        Notification* notification = notificationsMap.getValueAt(index);
+        const std::string& recipientUserId = notification->getRecipientUserId();
+        int userIndex = users.find(recipientUserId);
+        if (userIndex == -1)
+        {
+            throw std::runtime_error("Invalid recipient user ID");
         }
+        User* user = users.getValueAt(userIndex);
+        user->addNotification(notification);
     }
-	return filteredUsersMap;
+}
+
+/*
+Function: saveUsers
+Description: Saves users and their notifications from the datastore to persistent storage.
+             Collects notifications from all users into a single map before saving.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void UserManagementService::saveUsers()
+{
+    util::FileManager<User> userFileManager(config::file::USER_FILE);
+    util::FileManager<Notification> notificationFileManager(config::file::NOTIFICATION_FILE);
+    auto& users = m_dataStore.getUsers();
+    util::Map<std::string, Notification*> notifications;
+    for (int userIndex = 0; userIndex < users.getSize(); userIndex++)
+    {
+        User* user = users.getValueAt(userIndex);
+        auto& userNotifications = user->getNotifications();
+        for (int notificationIndex = 0; notificationIndex < userNotifications.getSize(); notificationIndex++)
+        {
+            notifications[userNotifications.getKeyAt(notificationIndex)] =
+                userNotifications.getValueAt(notificationIndex);
+        }
+    }
+    userFileManager.save(users);
+    notificationFileManager.save(notifications);
 }

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

@@ -6,7 +6,6 @@ Description: Header file declaring the UserManagementService class, which manage
 Author: Trenser
 Date:19-May-2026
 */
-
 #pragma once
 #include <string>
 #include "Map.h"
@@ -31,4 +30,6 @@ public:
     util::Vector<Notification*> getUserNotifications(const std::string& userID);
     void deleteNotification(const std::string& notificationID, const std::string& userID);
     void ensureAdminExists();
+    void loadUsers();
+    void saveUsers();
 };

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

@@ -15,7 +15,7 @@ namespace config
 	{
 		constexpr const char* DEFAULT_ADMIN_USERNAME = "admin";
 		constexpr const char* DEFAULT_ADMIN_NAME = "admin";
-		constexpr const char* DEFAULT_ADMIN_PASSWORD = "admin";
+		constexpr const char* DEFAULT_ADMIN_PASSWORD = "";
 		constexpr const char* DEFAULT_ADMIN_EMAIL = "admin@vss";
 		constexpr const char* DEFAULT_ADMIN_PHONE = "0000000000";
 	}
@@ -28,19 +28,16 @@ namespace config
 
 	namespace file
 	{
-		const size_t INITIAL_CAPACITY = 100;
-		const size_t GROWTH_FACTOR = 2;
-		constexpr const char* DIRECTORY = "files/";
-		constexpr const char* INVENTORYITEM_FILE = "files/InventoryItem.dat";
-		constexpr const char* USER_FILE = "files/User.dat";
-		constexpr const char* NOTIFICATION_FILE = "files/Notification.dat";
-		constexpr const char* SERVICE_FILE = "files/Service.dat";
-		constexpr const char* COMBOPACKAGE_FILE = "files/ComboPackage.dat";
-		constexpr const char* SERVICEBOOKING_FILE = "files/ServiceBooking.dat";
-		constexpr const char* JOBCARD_FILE = "files/JobCard.dat";
-		constexpr const char* INVOICE_FILE = "files/Invoice.dat";
-		constexpr const char* SERVICEMANAGEMENTOBSERVERS = "files/ServiceManagementObservers.dat";
-		constexpr const char* PAYMENTMANAGEMENTOBSERVERS = "files/PaymentManagementObservers.dat";
-		constexpr const char* INVENTORYMANAGEMENTOBSERVERS = "files/InventoryManagementObservers.dat";
+		constexpr const char* INVENTORYITEM_FILE = "files/InventoryItem.csv";
+		constexpr const char* USER_FILE = "files/User.csv";
+		constexpr const char* NOTIFICATION_FILE = "files/Notification.csv";
+		constexpr const char* SERVICE_FILE = "files/Service.csv";
+		constexpr const char* COMBOPACKAGE_FILE = "files/ComboPackage.csv";
+		constexpr const char* SERVICEBOOKING_FILE = "files/ServiceBooking.csv";
+		constexpr const char* JOBCARD_FILE = "files/JobCard.csv";
+		constexpr const char* INVOICE_FILE = "files/Invoice.csv";
+		constexpr const char* SERVICEMANAGEMENTOBSERVERS = "files/ServiceManagementObservers.csv";
+		constexpr const char* PAYMENTMANAGEMENTOBSERVERS = "files/PaymentManagementObservers.csv";
+		constexpr const char* INVENTORYMANAGEMENTOBSERVERS = "files/InventoryManagementObservers.csv";
 	}
 }

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

@@ -12,37 +12,32 @@ Date: 19-May-2026
 
 namespace util
 {
-	enum class UserType : int
+	enum class UserType
 	{
 		ADMIN,
 		TECHNICIAN,
 		CUSTOMER
 	};
 
-	enum class PaymentMode : int
+	enum class PaymentMode
 	{
 		ONLINE,
-		OFFLINE,
-        NOTSET
+		OFFLINE
 	};
 
-	enum class PaymentStatus : int
+	enum class PaymentStatus
 	{
 		PENDING,
-		COMPLETED,
-        PAID
+		COMPLETED
 	};
 
-	enum class ServiceJobStatus : int
+	enum class ServiceJobStatus
 	{
-        PENDING,
 		STARTED,
-		COMPLETED,
-        IN_PROGRESS,
-        CANCELLED
+		COMPLETED
 	};
 
-    enum class State : int
+    enum class State
     {
         ACTIVE,
         INACTIVE
@@ -113,8 +108,6 @@ namespace util
             return "ONLINE";
         case PaymentMode::OFFLINE:
             return "OFFLINE";
-        case PaymentMode::NOTSET:
-            return "NOTSET";
         }
         throw std::invalid_argument("Invalid PaymentMode");
     }
@@ -139,10 +132,6 @@ namespace util
         {
             return PaymentMode::OFFLINE;
         }
-        if (value == "NOTSET")
-        {
-            return PaymentMode::NOTSET;
-        }
         throw std::invalid_argument("Invalid PaymentMode string");
     }
 
@@ -162,8 +151,6 @@ namespace util
             return "PENDING";
         case PaymentStatus::COMPLETED:
             return "COMPLETED";
-        case PaymentStatus::PAID:
-            return "PAID";
         }
         throw std::invalid_argument("Invalid PaymentStatus");
     }
@@ -205,16 +192,10 @@ namespace util
     {
         switch (status)
         {
-        case ServiceJobStatus::PENDING:
-            return "PENDING";
         case ServiceJobStatus::STARTED:
             return "STARTED";
         case ServiceJobStatus::COMPLETED:
             return "COMPLETED";
-        case ServiceJobStatus::CANCELLED:
-            return "CANCELLED";
-        case ServiceJobStatus::IN_PROGRESS:
-            return "IN_PROGRESS";
         }
         throw std::invalid_argument("Invalid ServiceJobStatus");
     }
@@ -239,18 +220,6 @@ namespace util
         {
             return ServiceJobStatus::COMPLETED;
         }
-        if (value == "PENDING")
-        {
-            return ServiceJobStatus::PENDING;
-        }
-        if (value == "CANCELLED")
-        {
-            return ServiceJobStatus::CANCELLED;
-        }
-        if (value == "IN_PROGRESS")
-        {
-            return ServiceJobStatus::IN_PROGRESS;
-        }
         throw std::invalid_argument("Invalid ServiceJobStatus string");
     }
 

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

@@ -11,36 +11,69 @@ Date: 22-May-2026
 #include <fstream>
 #include <string>
 #include <stdexcept>
-#include <direct.h>
 #include "Vector.h"
 
 namespace util
 {
     /*
-    Function: ensureDirectoryExists
-    Description: Creates all missing directories present in the given file path.
-                Iteratively parses the path and creates each directory level
-                using _mkdir() before file operations are performed.
+    Function: loadRecords
+    Description: Loads records from a given file path into a vector of strings.
+                 Skips the header line if present. Creates the file if it does not exist.
     Parameters:
-        - filePath: const std::string&, relative or absolute file path
+        - filePath: const std::string&, path to the file
+    Returns:
+        - util::Vector<std::string>: Vector containing all records (excluding header)
+    Throws:
+        - None (creates file if missing)
+    */
+    inline util::Vector<std::string> loadRecords(const std::string& filePath)
+    {
+        util::Vector<std::string> records;
+        std::ifstream file(filePath);
+        if (!file.is_open())
+        {
+            std::ofstream newFile(filePath);
+            newFile.close();
+            file.open(filePath);
+        }
+        std::string line;
+        bool isHeader = true;
+        while (std::getline(file, line))
+        {
+            if (isHeader)
+            {
+                isHeader = false;
+                continue;
+            }
+            records.push_back(line);
+        }
+        return records;
+    }
+
+    /*
+    Function: saveRecords
+    Description: Saves records to a given file path. Overwrites existing content
+                 and writes a header line followed by all records.
+    Parameters:
+        - filePath: const std::string&, path to the file
+        - records: const util::Vector<std::string>&, vector of records to save
     Returns:
         - void
     Throws:
-        - None (_mkdir failures are intentionally ignored if directory already exists)
+        - std::runtime_error if the file cannot be opened for writing
     */
-    inline void ensureDirectoryExists(const std::string& filePath)
+    inline void saveRecords(const std::string& filePath, const util::Vector<std::string>& records)
     {
-        size_t position = 0;
-
-        while ((position = filePath.find('/', position)) != std::string::npos)
+        std::ofstream file(filePath, std::ios::trunc);
+        if (!file.is_open())
         {
-            std::string directory = filePath.substr(0, position);
-
-            if (!directory.empty())
-            {
-                (void)_mkdir(directory.c_str());
+            throw std::runtime_error("Failed to open file " + filePath);
         }
-            position++;
+        file << "Values" << '\n';
+        int numberOfRecords = records.getSize();
+        for (int index = 0; index < numberOfRecords; index++)
+        {
+            file << records[index] << '\n';
         }
     }
 }

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

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

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

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

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/OutputHelper.h

@@ -21,28 +21,4 @@ namespace util
     {
         std::cout << "\x1B[2J\x1B[H" << std::flush;
     }
-
-    /*
-    Function: truncateString
-    Description:
-        Truncates a string if its length exceeds the given maximum length.
-        The truncated string ends with "..." to indicate omitted characters.
-    Parameters:
-        - text: const std::string&, input string to truncate
-        - maxLength: size_t, maximum allowed length of the returned string
-    Returns:
-        - std::string: Original string if within limit, otherwise truncated string with "..."
-    */
-    inline std::string truncateString(const std::string& text, size_t maxLength)
-    {
-        if (text.length() <= maxLength)
-        {
-            return text;
-        }
-        if (maxLength <= 3)
-        {
-            return std::string(maxLength, '.');
-        }
-        return text.substr(0, maxLength - 3) + "...";
-    }
 }

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

@@ -1,12 +1,12 @@
 /*
 File: Utility.h
-Description: Header file declaring utility functions used across the system
+Description: Header file declaring utility functions used across the system,
+             including cost calculation for services and combo packages.
 Author: Trenser
 Date:19-May-2026
 */
 
 #pragma once
-#include "ComboPackage.h"
 #include "DataStore.h"
 #include "FileHelper.h"
 #include "InventoryItem.h"
@@ -35,14 +35,14 @@ namespace util
     }
 
     /*
-    Function: calculateComboServiceEstimatedCost
-    Description: Calculates the estimated total cost of a combo package by summing
+Function: calculateComboServiceEstimatedCost
+Description: Calculates the estimated total cost of a combo package by summing
              the labor and parts costs of all services included in the package.
-    Parameter: const ComboPackage* comboPackage - pointer to the combo package object
-    Return type: double - estimated total cost of the combo package
+Parameter: const ComboPackage* comboPackage - pointer to the combo package object
+Return type: double - estimated total cost of the combo package
     */
-    inline double calculateComboServiceEstimatedCost(const ComboPackage* comboPackage)
-    {
+inline double calculateComboServiceEstimatedCost(const ComboPackage* comboPackage)
+{
     double cost = 0;
     auto& services = comboPackage->getServices();
     int servicesSize = services.getSize();
@@ -52,81 +52,50 @@ namespace util
         cost += calculatePartsCost(service) + service->getLaborCost();
     }
     return cost;
-    }
-
-    template<typename TObject>
-    Map<std::string, TObject*> getObjects(const Map<std::string, TrackedRecord<TObject>>& trackedRecords);
-
-    template<typename TObject>
-    Map<std::string, const TObject*> getConstObjects(const Map<std::string, TrackedRecord<TObject>>& trackedRecords);
-
-    template<typename TObject>
-    TrackedRecord<TObject> createNewRecord(TObject* object);
 }
 
 /*
-Function: getObjects
-Description: Extracts the object pointers from a tracked-record
-             collection and returns them as a map keyed by the
-             same identifiers.
+Function: loadObservers
+Description: Loads observer IDs from a file and attaches the corresponding users
+             to the notification management service. Validates that each observer ID
+             exists in the datastore before attaching.
 Parameters:
-    - trackedRecords: Collection of tracked records.
+    - filePath: const std::string&, path to the file containing observer IDs
+    - service: NotificationManagementService*, pointer to the notification service
+    - dataStore: DataStore&, reference to the datastore containing users
 Returns:
-    - Map<std::string, TObject*>: Collection of object pointers.
+    - void
+Throws:
+    - std::runtime_error if an observer ID is invalid (not found in datastore)
 */
-template<typename TObject>
-util::Map<std::string, TObject*> util::getObjects(const util::Map<std::string, TrackedRecord<TObject>>& trackedRecords)
+inline void loadObservers(const std::string& filePath, NotificationManagementService* service, DataStore& dataStore)
 {
-    util::Map<std::string, TObject*> objects;
-    for (int index = 0; index < trackedRecords.getSize(); ++index)
+    auto observerIDs = util::loadRecords(filePath);
+    auto& users = dataStore.getUsers();
+    for (int index = 0; index < observerIDs.getSize(); index++)
     {
-        const std::string& key = trackedRecords.getKeyAt(index);
-        TObject* object = trackedRecords.getValueAt(index).data;
-        objects.insert(key, object);
-    }
-    return objects;
-}
-
-/*
-Function: getConstObjects
-Description: Extracts the object pointers from a tracked-record
-             collection and returns them as a read-only map
-             keyed by the same identifiers.
-Parameters:
-    - trackedRecords: Collection of tracked records.
-Returns:
-    - Map<std::string, const TObject*>:
-      Collection of read-only object pointers.
-*/
-template<typename TObject>
-util::Map<std::string, const TObject*> util::getConstObjects(
-    const util::Map<std::string, TrackedRecord<TObject>>& trackedRecords)
-{
-    util::Map<std::string, const TObject*> objects;
-    for (int index = 0; index < trackedRecords.getSize(); ++index)
+        const std::string& observerID = observerIDs[index];
+        int userIndex = users.find(observerID);
+        if (userIndex == -1)
         {
-        const std::string& key = trackedRecords.getKeyAt(index);
-        const TObject* object = trackedRecords.getValueAt(index).data;
-        objects.insert(key, object);
+            throw std::runtime_error("Invalid Observer ID");
+        }
+        service->attach(users.getValueAt(userIndex));
     }
-    return objects;
 }
 
 /*
-Function: createNewRecord
-Description: Creates a tracked record for a newly created
-             object. The record is initialized with
-             NEW_RECORD state.
+Function: saveObservers
+Description: Saves the current observer IDs from the notification management service
+             to a file for persistence.
 Parameters:
-    - object: Pointer to the newly created object.
+    - filePath: const std::string&, path to the file where observer IDs will be saved
+    - service: NotificationManagementService*, pointer to the notification service
 Returns:
-    - TrackedRecord<TObject>: Initialized tracked record.
+    - void
 */
-template<typename TObject>
-TrackedRecord<TObject> util::createNewRecord(TObject* object)
+inline void saveObservers(const std::string& filePath, NotificationManagementService* service)
 {
-    TrackedRecord<TObject> record;
-    record.data = object;
-    record.state = RecordState::NEW_RECORD;
-    return record;
+    auto observerIDs = service->getObserverIDs();
+    util::saveRecords(filePath, observerIDs);
 }

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

@@ -107,67 +107,3 @@ bool util::isPasswordValid(const std::string& password)
 
     return hasUpper && hasLower && hasDigit && hasSpecial;
 }
-
-/*
- * Function: isUsernameDuplicate
- * Description: Checks if the given username already exists among active users.
- * Parameters:
- *     username - string containing the username to validate
- *     usersMap - map of user objects keyed by identifier
- * Returns:
- *     bool - true if the username is already in use by an active user, false otherwise
- */
-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);
-        }
-    );
-    return index != -1;
-}
-
-/*
- * Function: isPhoneDuplicate
- * Description: Checks if the given phone number already exists among active users.
- * Parameters:
- *     phone - string containing the phone number to validate
- *     usersMap - map of user objects keyed by identifier
- * Returns:
- *     bool - true if the phone number is already in use by an active user, false otherwise
- * Notes:
- *     - Only considers users with state util::State::ACTIVE
- */
-bool util::isPhoneDuplicate(const std::string& phone, const util::Map<std::string, User*>& usersMap)
-{
-    int index = usersMap.findIf(
-        [&](const std::string&, User* user)
-        {
-            return (user->getPhone() == phone && user->getState() == util::State::ACTIVE);
-        }
-    );
-    return index != -1;
-}
-
-/*
- * Function: isEmailDuplicate
- * Description: Checks if the given email address already exists among active users.
- * Parameters:
- *     email - string containing the email address to validate
- *     usersMap - map of user objects keyed by identifier
- * Returns:
- *     bool - true if the email address is already in use by an active user, false otherwise
- * Notes:
- *     - Only considers users with state util::State::ACTIVE
- */
-bool util::isEmailDuplicate(const std::string& email, const util::Map<std::string, User*>& usersMap)
-{
-    int index = usersMap.findIf(
-        [&](const std::string&, User* user)
-        {
-            return (user->getEmail() == email && user->getState() == util::State::ACTIVE);
-        }
-    );
-    return index != -1;
-}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/Validator.h

@@ -9,15 +9,10 @@
 #include<string>
 #include<algorithm>
 #include<cctype>
-#include "Map.h"
-#include "User.h"
 
 namespace util
 {
 	bool isPhoneNumberValid(const std::string&);
 	bool isEmailValid(const std::string&);
 	bool isPasswordValid(const std::string&);
-	bool isUsernameDuplicate(const std::string&, const util::Map<std::string, User*>&);
-	bool isPhoneDuplicate(const std::string&, const util::Map<std::string, User*>&);
-	bool isEmailDuplicate(const std::string&, const util::Map<std::string, User*>&);
 }

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

@@ -8,64 +8,34 @@ Author: Trenser
 Date: 19-May-2026
 */
 
-#include <iomanip>
-#include <iostream>
 #include "AdminMenu.h"
-#include "Enums.h"
 #include "InputHelper.h"
-#include "InventoryItem.h"
-#include "MenuHelper.h"
 #include "OutputHelper.h"
-#include "Service.h"
-#include "ServiceBooking.h"
-#include "User.h"
-#include "Utility.h"
-#include "Validator.h"
+#include "MenuHelper.h"
 
 /*
 Function: showMenu
-Description: Displays the admin menu and handles user input until logout is selected.
-Parameter: None
-Return type: void
+Description: Displays the admin menu in a loop until the user chooses to logout.
+			 Handles exceptions and ensures smooth user interaction.
+Parameters:
+	- None
+Returns:
+	- void
 */
 void AdminMenu::showMenu()
 {
-	startEventListener();
-    while (true)
+	bool isMenuActive = true;
+	while (isMenuActive)
 	{
 		try
 		{
-			if (!m_isMenuActive)
-			{
-				logout();
-				break;
-			}
 			int choice;
 			util::clear();
-            std::cout << "Admin Menu"
-                << "\n1. View Stock Levels"
-                << "\n2. Add Inventory Item"
-                << "\n3. Remove Inventory Item"
-                << "\n4. Check Stock Availability"
-                << "\n5. Assign Job to Technician"
-                << "\n6. Display Users"
-                << "\n7. Add Technician"
-                << "\n8. Remove Customer/Technician"
-                << "\n9. Display Services"
-                << "\n10. Create Service"
-                << "\n11. Remove Service"
-                << "\n12. Display Combo Packages"
-                << "\n13. Create Combo Package"
-                << "\n14. Remove Combo Package"
-                << "\n15. View Notifications"
-                << "\n16. Change Password"
-				<< "\n17. Confirm Payment"
-                << "\n18. Logout"
-                << "\nEnter a choice: ";
+			std::cout << "" << std::endl;
 			util::read(choice);
 			if (!handleOperation(choice))
 			{
-                break;
+				isMenuActive = false;
 			}
 		}
 		catch (const std::exception& e)
@@ -74,722 +44,64 @@ void AdminMenu::showMenu()
 			util::pressEnter();
 		}
 	}
-	stopEventListener();
 }
 
-/*
-Function: handleOperation
-Description: Executes the corresponding admin operation based on the selected menu choice.
-Parameter: int choice - selected menu option
-Return type: bool - true if menu continues, false if logout
-*/
 bool AdminMenu::handleOperation(int choice)
 {
-	if (!m_isMenuActive)
-	{
-		logout();
 	return false;
-	}
-    switch (choice)
-    {
-    case 1:
-        viewStockLevels();
-        break;
-    case 2:
-        addInventoryItem();
-        break;
-    case 3:
-        removeInventoryItem();
-        break;
-    case 4:
-        checkStockAvailability();
-        break;
-    case 5:
-        assignJob();
-        break;
-    case 6:
-        displayUsers();
-        break;
-    case 7:
-        addTechnician();
-        break;
-    case 8:
-        removeUser();
-        break;
-    case 9:
-        displayServices();
-        break;
-    case 10:
-        createService();
-        break;
-    case 11:
-        removeService();
-        break;
-    case 12:
-        displayComboPackages();
-        break;
-    case 13:
-        createComboPackages();
-        break;
-    case 14:
-        removeComboPackage();
-        break;
-    case 15:
-        viewNotifications();
-        break;
-    case 16:
-        changePassword();
-        break;
-	case 17:
-		confirmPayment();
-		break;
-    case 18:
-        logout();
-        return false;
-    default:
-        std::cout << "Enter a valid choice!" << std::endl;
-        util::pressEnter();
-    }
-    return true;
 }
 
-/*
-Function: handleNotificationEvent
-Description: Retrieves and displays the latest notification for the
-			 currently logged in admin.
-Parameter: None
-Return type: void
-*/
-void AdminMenu::handleNotificationEvent()
-{
-	auto notifications = m_controller.getNotifications();
-	const User* authenticatedUser = m_controller.getAuthenticatedUser();
-	std::string name;
-	if (authenticatedUser)
-	{
-		name = authenticatedUser->getName();
-	}
-	displayNewNotification(notifications, name);
-}
 
-/*
-Function: logout
-Description: Logs out the currently authenticated admin user.
-Parameter: None
-Return type: void
-*/
 void AdminMenu::logout()
 {
-	m_controller.logout();
 }
 
-/*
-Function: changePassword
-Description: Allows the admin to change their password after validation.
-Parameter: None
-Return type: void
-*/
 void AdminMenu::changePassword()
 {
-	changePasswordHelper(m_controller);
 }
 
-/*
-Function: viewStockLevels
-Description: Displays all active inventory items with their details
-             including ID, part name, quantity, and price.
-Parameter: None
-Return type: void
-*/
 void AdminMenu::viewStockLevels()
 {
-    util::clear();
-	auto inventoryItems = m_controller.getInventoryItems();
-	bool hasActiveItems = false;
-	std::cout << "View Stock Levels" << std::endl;
-	if (inventoryItems.isEmpty())
-	{
-		std::cout << "No items found in Inventory.\n";
-		util::pressEnter();
-		return;
-	}
-	for (int index = 0; index < inventoryItems.getSize(); index++)
-	{
-		const InventoryItem* item = inventoryItems.getValueAt(index);
-		if (item->getState() == util::State::ACTIVE)
-		{
-			hasActiveItems = true;
-			break;
-		}
-	}
-	if (!hasActiveItems)
-	{
-		std::cout << "No active Inventory Item found.\n";
-		util::pressEnter();
-		return;
-	}
-	std::cout << std::left << std::setw(15) << "Item ID"
-		<< std::setw(25) << "Part Name"
-		<< std::setw(15) << "Quantity"
-		<< std::setw(15) << "Price"
-		<< std::endl;
-	for (int iterator = 0; iterator < inventoryItems.getSize(); ++iterator)
-	{
-		const InventoryItem* item = inventoryItems.getValueAt(iterator);
-		if (item != nullptr)
-		{
-			if (item->getState() != util::State::INACTIVE)
-			{
-				std::cout << std::left << std::setw(15) << item->getId()
-					<< std::setw(25) << item->getPartName()
-					<< std::setw(15) << item->getQuantity()
-					<< std::setw(15) << item->getPrice()
-					<< std::endl;
-			}
-		}
-	}
-	std::cout << "\n";
-	util::pressEnter();
 }
 
-/*
-Function: addInventoryItem
-Description: Allows the admin to either add a new inventory item
-             or increase the quantity of an existing item.
-Parameter: None
-Return type: void
-*/
 void AdminMenu::addInventoryItem()
 {
-	util::clear();
-	int choice, quantity;
-	double price;
-	std::string partName;
-	std::cout << "Add Inventory Item\n";
-	std::cout << "1. Add new item \n2. Restock Item\n\nEnter your choice : ";
-	util::read(choice);
-	switch (choice)
-	{
-	case 1:
-	{
-		util::clear();
-		std::cout << "Enter Item Details\n";
-		std::cout << "Part Name : ";
-		util::read(partName);
-		std::cout << "Quantity : ";
-		util::read(quantity);
-		std::cout << "Price : ";
-		util::read(price);
-		m_controller.addInventoryItem(partName, quantity, price);
-		std::cout << "\nNew Item " << partName << " added to the Inventory.\n\n";
-		break;
-	}
-	case 2:
-	{
-		util::clear();
-		std::cout << "Select Item to Restock\n";
-		auto inventoryItems = m_controller.getInventoryItems();
-		addQuantityToItem(inventoryItems, m_controller);
-		break;
-	}
-	default:
-	{
-		std::cout << "\nEnter a valid choice.\n\n";
-	}
-	}
-	util::pressEnter();
 }
 
-/*
-Function: removeInventoryItem
-Description: Removes an active inventory item by marking it inactive
-             after user selection.
-Parameter: None
-Return type: void
-*/
 void AdminMenu::removeInventoryItem()
 {
-    util::clear();
-	std::cout << "Remove Inventory Item\n";
-    auto inventoryItems = m_controller.getInventoryItems();
-    auto activeItems = filterActiveItems(inventoryItems);
-    int activeItemsSize = activeItems.getSize();
-    if (activeItemsSize == 0)
-    {
-        std::cout << "No items available in Inventory." << std::endl;
-        util::pressEnter();
-        return;
-    }
-    displayInventoryWithItems(activeItems);
-    int itemIndex;
-    std::cout << "Enter the index of the item to remove: ";
-    util::read(itemIndex);
-    if (itemIndex < 1 || itemIndex > activeItemsSize)
-    {
-        std::cout << "Invalid index selected." << std::endl;
-        util::pressEnter();
-        return;
-    }
-    const InventoryItem* selectedItem = activeItems.getValueAt(itemIndex - 1);
-    if (selectedItem != nullptr)
-    {
-        if(selectedItem->getState() != util::State::INACTIVE)
-        {
-            std::string selectedItemId = selectedItem->getId();
-            m_controller.removeInventoryItem(selectedItemId);
-            std::cout << "Item " << selectedItem->getPartName() << " removed successfully." << std::endl;
-			const util::Map<std::string, const Service*>& listOfService = m_controller.getServices();
-			for (int serviceIndex = 0; serviceIndex < listOfService.getSize(); serviceIndex++)
-			{
-				const Service* service = listOfService.getValueAt(serviceIndex);
-				if (!service)
-				{
-					continue;
-				}
-				const util::Map<std::string, InventoryItem*>& requiredItems = service->getRequiredInventoryItems();
-				if (requiredItems.find(selectedItemId) != -1) 
-				{
-					m_controller.removeService(service->getId()); 
-					std::cout << "Service " << service->getName()
-						<< " removed as the item "
-						<< selectedItem->getPartName() << " required for the service has been removed." << std::endl;
-				}
-			}
-        }
-    }
-    util::pressEnter();
 }
 
-/*
-Function: checkStockAvailability
-Description: Checks if a specific inventory item is available
-             and displays its details if active.
-Parameter: None
-Return type: void
-*/
 void AdminMenu::checkStockAvailability()
 {
-	util::clear();
-	std::string itemId;
-	std::cout << "Check Stock Availability \n";
-	std::cout << "Enter the Item ID : ";
-	util::read(itemId);
-	util::clear();
-	const InventoryItem* selectedItem = m_controller.getInventoryItem(itemId);
-	if (selectedItem != nullptr)
-	{
-		if (selectedItem->getState() != util::State::INACTIVE)
-		{
-			std::cout << "Item Details\n";
-			std::cout << "---------------------------------------------\n";
-			std::cout << "Item ID      : " << selectedItem->getId() << "\n";
-			std::cout << "Part Name    : " << selectedItem->getPartName() << "\n";
-			std::cout << "Quantity     : " << selectedItem->getQuantity() << "\n";
-		}
-	}
-	else
-	{
-		std::cout << "Item not Found" << std::endl;
-	}
-	util::pressEnter();
 }
 
-/*
-Function: assignJob
-Description: Allows the admin to assign pending service bookings to available technicians.
-			 Creates job cards for selected services.
-Parameters:
-	- None
-Returns:
-	- void
-*/
 void AdminMenu::assignJob()
 {
-	util::clear();
-	std::cout << "Assign Job to Technician\n";
-	std::string selectedService;
-	bool hasPendingService = false;
-	auto currentBookings = m_controller.getServiceBookings();
-	auto pendingServiceBookings = filterActiveServiceBookings(currentBookings);
-	auto availableTechnicians = m_controller.getUsers(util::UserType::TECHNICIAN);
-	int bookingsSize = pendingServiceBookings.getSize();
-	util::Map<int, const ServiceBooking*> serviceBookingsMap;
-	util::Map<int, const User*> currentAvailableTechniciansMap;
-	if (listServiceBookings(pendingServiceBookings, bookingsSize, serviceBookingsMap))
-	{
-		const ServiceBooking* selectedService = selectPendingServiceBookings(serviceBookingsMap);
-		if (selectedService)
-		{
-			if (availableTechnicians.getSize() != 0)
-			{
-				listAvailableTechnicians(availableTechnicians, availableTechnicians.getSize(), currentAvailableTechniciansMap);
-				const User* selectedTechnician = selectTechnician(currentAvailableTechniciansMap);
-				if (selectedTechnician)
-				{
-					auto& servicesInBooking = selectedService->getServices();
-					for (int iterator = 0; iterator < servicesInBooking.getSize(); iterator++)
-					{
-						m_controller.createJobCard(selectedService->getId(), selectedTechnician->getId(), servicesInBooking.getValueAt(iterator)->getId());
-					}
-					std::cout << "Job card created for each service and technician successfully assigned.\n\n";
-				}
-			}
-			else
-			{
-				std::cout << "No technicians are currently available.\n\n";
-			}
-		}
-	}
-	else
-	{
-		std::cout << "No pending service bookings available.\n\n";
-	}
-	util::pressEnter();
 }
 
-/*
-Function: displayServices()
-Description: Display all active services
-Parameters:
-	- None
-Returns:
-	- void
-*/
-void AdminMenu::displayServices()
-{
-	util::clear();
-	std::cout << "List of all Services\n";
-	util::Map<std::string, const Service*> currentServices = m_controller.getServices();
-	util::Map<std::string, const Service*> currentActiveServices = filterActiveServices(currentServices);
-	displayAllServices(currentActiveServices);
-	util::pressEnter();
-}
-
-/*
-Function: createService
-Description: Allows the admin to create a new service by selecting inventory items and specifying labor cost.
-Parameters:
-	- None
-Returns:
-	- void
-*/
 void AdminMenu::createService()
 {
-	util::clear();
-	std::cout << "Create Service\n";
-	std::string serviceName;
-	double labourCost;
-	std::cout << "Enter the service name: ";
-	util::read(serviceName);
-	util::Map<std::string, const InventoryItem*> currentInventoryItems = m_controller.getInventoryItems();
-	util::Map<std::string, const InventoryItem*> activeInventoryItems = filterActiveItems(currentInventoryItems);
-	util::Vector<std::string> selectedInventoryItems;
-	selectInventoryItems(activeInventoryItems,selectedInventoryItems);
-	if (selectedInventoryItems.isEmpty())
-	{
-		util::pressEnter();
-		return;
-	}
-	std::cout << "\nEnter the labour cost: ";
-	util::read(labourCost);
-    m_controller.createService(serviceName, selectedInventoryItems, labourCost);
-    std::cout << "\nService created sucessfully.\n\n";
-	util::pressEnter();
 }
 
-/*
-Function: removeService
-Description: Allows the admin to remove an existing service by selecting from available services.
-Parameters:
-	- None
-Returns:
-	- void
-*/
 void AdminMenu::removeService()
 {
-	util::clear();
-	std::cout << "Remove Service\n";
-	std::string selectedServiceID;
-	util::Map<std::string, const Service*> currentServices = m_controller.getServices();
-	util::Map<std::string, const Service*> currentActiveServices = filterActiveServices(currentServices);
-	selectedServiceID = selectServicesToRemove(currentActiveServices);
-	if (selectedServiceID != "")
-	{
-		m_controller.removeService(selectedServiceID);
-		std::cout << "Service removed successfully.\n\n";
-	}
-	else
-	{
-		std::cout << "Failed  to remove service.\n\n";
-	}
-	util::pressEnter();
 }
 
-/*
-Function: displayUsers
-Description: Displays all users.
-Parameter: None
-Return type: void
-*/
-void AdminMenu::displayUsers()
-{
-	util::clear();
-	auto listOfUsers = m_controller.getUsers();
-	auto listOfActiveUsers = filterActiveUsers(listOfUsers);
-	int activeUserCount = listOfActiveUsers.getSize();
-	std::cout << "List of all Users\n";
-	if (activeUserCount < 1)
-	{
-		std::cout << "No Active users." << std::endl;
-		util::pressEnter();
-		return;
-	}
-	displayAllUsers(listOfActiveUsers);
-	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.
-Parameter: None
-Return type: void
-*/
 void AdminMenu::addTechnician()
 {
-	util::clear();
-	std::string username, name, password, email, phoneNumber;
-	std::cout << "Add Technician\n";
-	std::cout << "Enter Technician Username: ";
-	util::read(username);
-	std::cout << "Enter Technician Name: ";
-	util::read(name);
-	std::cout << "Enter Technician Password: ";
-	util::read(password);
-	if(!util::isPasswordValid(password))
-	{
-		std::cout << "\nError: Password is invalid!\n\n";
-		util::pressEnter();
-		return;
-	}
-	std::cout << "Enter Technician Email: ";
-	util::read(email);
-	if(!util::isEmailValid(email))
-	{
-		std::cout << "\nError: Email is invalid!\n\n";
-		util::pressEnter();
-		return;
-	}
-	std::cout << "Enter Technician Phone: ";
-	util::read(phoneNumber);
-	if(!util::isPhoneNumberValid(phoneNumber))
-	{
-		std::cout << "\nError: Phone Number is invalid!\n\n";
-		util::pressEnter();
-		return;
-	}
-	m_controller.createTechnician(username, name, password, email, phoneNumber);
-	std::cout << "\nTechnician Added Successfully.\n\n";
-	util::pressEnter();
 }
 
-/*
-Function: removeUser
-Description: Removes a selected active user (customer or technician) from the system.
-Parameter: None
-Return type: void
-*/
 void AdminMenu::removeUser()
 {
-	util::clear();
-	int indexChoice;
-	auto listOfUsers = m_controller.getUsers();
-	auto listOfActiveUsers = filterActiveUsers(listOfUsers);
-	int activeUserCount = listOfActiveUsers.getSize();
-	std::cout << "Remove User \n";
-	if (activeUserCount < 1)
-	{
-		std::cout << "No Active users." << std::endl;
-		util::pressEnter();
-		return;
-	}
-	displayAllUsers(listOfActiveUsers);
-	std::cout << "Enter the index of the user to delete : ";
-	util::read(indexChoice);
-	if (indexChoice < 1 || indexChoice > activeUserCount)
-	{
-		std::cout << "Error invalid index.\n" << std::endl;
-		util::pressEnter();
-		return;
-	}
-	const User* userToRemove = listOfActiveUsers.getValueAt(indexChoice - 1);
-	if (userToRemove != nullptr)
-	{
-		std::string userIdToRemove = userToRemove->getId();
-		m_controller.removeUser(userIdToRemove);
-		std::cout << userToRemove->getUserName() << " removed Successfully.\n";
-	}
-	util::pressEnter();
 }
 
-/*
-Function: displayComboPackages()
-Description: Display all active combo packages
-Parameters:
-	- None
-Returns:
-	- void
-*/
-void AdminMenu::displayComboPackages()
-{
-	util::clear();
-	std::cout << "List of all Combo Packages\n";
-	util::Map<std::string, const ComboPackage*> currentComboPackages = m_controller.getComboPackages();
-	util::Map<std::string, const ComboPackage*> currentActiveComboPackages = filterComboPackages(currentComboPackages);
-	displayAllComboPackages(currentActiveComboPackages);
-	util::pressEnter();
-}
-
-/*
-Function: createComboPackages
-Description: Creates a new combo package by selecting two active services and applying a discount.
-Parameter: None
-Return type: void
-*/
 void AdminMenu::createComboPackages()
 {
-	util::clear();
-	std::cout << "Create Combo Packages\n";
-	auto serviceList = m_controller.getServices();
-	auto activeServices = filterActiveServices(serviceList);
-	int currentActiveServicesCount = activeServices.getSize();
-    const int NUMBER_OF_SERVICE_PER_PACKAGE = 2;
-	util::Vector<std::string> selectedServiceID;
-    for (int iterator = 0; iterator < NUMBER_OF_SERVICE_PER_PACKAGE; iterator++)
-    {
-        const Service* chosenService = nullptr;
-        while (true)
-        {
-            chosenService = selectServiceFromServices(activeServices);
-            if (!chosenService)
-            {
-                std::cout << "Failed to create combo package!\n\n";
-                util::pressEnter();
-                return;
-            }
-            bool alreadyChosen = false;
-            for (int iteratorOne = 0; iteratorOne < selectedServiceID.getSize(); iteratorOne++)
-            {
-                if (selectedServiceID[iteratorOne] == chosenService->getId())
-                {
-                    alreadyChosen = true;
-                    break;
-                }
-            }
-            if (alreadyChosen)
-            {
-				if (currentActiveServicesCount < 2)
-				{
-					break;
-				}
-                std::cout << "Service already selected. Please choose a different one." << std::endl;
-                continue; 
-            }
-            selectedServiceID.push_back(chosenService->getId());
-            break;
-        }
-		if (currentActiveServicesCount < 2)
-		{
-			std::cout << "All the available services selected\n\n";
-			break;
-		}
-    }
-    std::string packageName;
-    double discountPercentage;
-    std::cout << "Enter combo package name: ";
-    util::read(packageName);
-    std::cout << "Enter discount percentage: ";
-    util::read(discountPercentage);
-    if (discountPercentage < 0.0 || discountPercentage > 100.0)
-    {
-        std::cout << "Error: Discount percentage must be between 0 and 100." << std::endl;
-        util::pressEnter();
-        return;
-    }
-    m_controller.createComboPackage(packageName, selectedServiceID, discountPercentage);
-    std::cout << "Combo package '" << packageName << "' created successfully." << std::endl;
-    util::pressEnter();
 }
 
-/*
-Function: removeComboPackage
-Description: Removes a selected combo package from the system.
-Parameter: None
-Return type: void
-*/
 void AdminMenu::removeComboPackage()
 {
-	util::clear();
-	std::cout << "Remove Combo Package\n";
-	util::Map<std::string, const ComboPackage*> currentComboPackages = m_controller.getComboPackages();
-	std::string selectedComboPackageID = selectComboPackage(currentComboPackages);
-	if (!selectedComboPackageID.empty())
-	{
-		m_controller.removeComboPackage(selectedComboPackageID);
-		std::cout << "Combo Package removed successfully.\n\n";
-	}
-	else
-	{
-		std::cout << "Combo package removal failed.\n\n";
-	}
-	util::pressEnter();
 }
 
 /*

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

@@ -1,21 +1,20 @@
 /*
 File: AdminMenu.h
-Description: Header file declaring the AdminMenu class, which provides
-             administrative operations such as inventory management,
-             user management, service configuration, and notifications.
+Description: Declares the AdminMenu class which provides the administrative console menu in the Vehicle Service Management System.
+             Supports operations such as inventory management, job assignment, service creation/removal, technician management,
+             combo package handling, notification viewing, and account management functions like logout and password change.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
 
 #pragma once
 #include "Controller.h"
-#include "Menu.h"
 
-class AdminMenu : public Menu
+class AdminMenu
 {
 private:
+    Controller m_controller;
     bool handleOperation(int choice);
-    void handleNotificationEvent() override;
 public:
     void showMenu();
     void logout();
@@ -25,14 +24,10 @@ public:
     void removeInventoryItem();
     void checkStockAvailability();
     void assignJob();
-    void displayServices();
     void createService();
     void removeService();
-    void displayUsers();
-    void confirmPayment();
     void addTechnician();
     void removeUser();
-    void displayComboPackages();
     void createComboPackages();
     void removeComboPackage();
     void viewNotifications();

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

@@ -6,21 +6,16 @@ Description: Implementation file containing the method definitions of the
 Author: Trenser
 Date:19-May-2026
 */
-
 #include <iomanip>
 #include "ComboPackage.h"
 #include "CustomerMenu.h"
-#include "MenuHelper.h"
-#include "Enums.h"
 #include "InputHelper.h"
-#include "OutputHelper.h"
 #include "InventoryItem.h"
-#include "Invoice.h"
 #include "Map.h"
+#include "MenuHelper.h"
+#include "OutputHelper.h"
 #include "Service.h"
-#include "ServiceBooking.h"
-#include "Timestamp.h"
-#include "User.h"
+#include "Utility.h"
 #include "Validator.h"
 #include "Vector.h"
 
@@ -32,17 +27,10 @@ Return type: void
 */
 void CustomerMenu::showMenu()
 {
-
-    startEventListener();
     while (true)
     {
         try
         {
-            if (!m_isMenuActive)
-            {
-                logout();
-                break;
-            }
             int choice;
             util::clear();
             std::cout << "Customer Menu"
@@ -51,12 +39,11 @@ void CustomerMenu::showMenu()
                 << "\n3. Update Profile"
                 << "\n4. Change Password"
                 << "\n5. View Service History"
-                << "\n6. Cancel Service Booking"
-                << "\n7. Complete Payments"
-                << "\n8. View Invoices"
-                << "\n9. View Notifications"
-                << "\n10. Configure Notifications"
-                << "\n11. Logout"
+                << "\n6. Complete Payments"
+                << "\n7. View Invoices"
+                << "\n8. View Notifications"
+                << "\n9. Configure Notifications"
+                << "\n10. Logout"
                 << "\nEnter a choice: ";
             util::read(choice);
             if (!handleOperation(choice))
@@ -70,7 +57,6 @@ void CustomerMenu::showMenu()
             util::pressEnter();
         }
     }
-    stopEventListener();
 }
 
 /*
@@ -81,11 +67,6 @@ Return type: bool - true if menu continues, false if logout
 */
 bool CustomerMenu::handleOperation(int choice)
 {
-    if (!m_isMenuActive)
-    {
-        logout();
-        return false;
-    }
     switch (choice)
     {
     case 1:
@@ -104,21 +85,18 @@ bool CustomerMenu::handleOperation(int choice)
         viewServiceHistory();
         break;
     case 6:
-        cancelServiceBooking();
-        break;
-    case 7:
         completePayments();
         break;
-    case 8:
+    case 7:
         viewInvoices();
         break;
-    case 9:
+    case 8:
         viewNotifications();
         break;
-    case 10:
+    case 9:
         configureNotifications();
         break;
-    case 11:
+    case 10:
         logout();
         return false;
     default:
@@ -128,25 +106,6 @@ bool CustomerMenu::handleOperation(int choice)
     return true;
 }
 
-/*
-Function: handleNotificationEvent
-Description: Retrieves and displays the latest notification for the
-             currently logged in admin.
-Parameter: None
-Return type: void
-*/
-void CustomerMenu::handleNotificationEvent()
-{
-    auto notifications = m_controller.getNotifications();
-    const User* authenticatedUser = m_controller.getAuthenticatedUser();
-    std::string name;
-    if (authenticatedUser)
-    {
-        name = authenticatedUser->getName();
-    }
-    displayNewNotification(notifications, name);
-}
-
 /*
 Function: logout
 Description: Logs out the currently authenticated customer user.
@@ -166,7 +125,19 @@ Return type: void
 */
 void CustomerMenu::changePassword()
 {
-    changePasswordHelper(m_controller);
+	std::string newPassword;
+	util::clear();
+	std::cout << "Enter new password: ";
+	util::read(newPassword);
+	m_controller.changePassword(newPassword);
+	if (!util::isPasswordValid(newPassword))
+	{
+		std::cout << "Error: Password is not strong enough!";
+		util::pressEnter();
+		return;
+	}
+	std::cout << "Password changed successfully";
+	util::pressEnter();
 }
 
 /*
@@ -179,12 +150,11 @@ void CustomerMenu::updateDetails()
 {
 	std::string email, phone;
 	util::clear();
-    std::cout << "Update Details\n";
 	std::cout << "Enter new email: ";
 	util::read(email);
 	if (!util::isEmailValid(email))
 	{
-		std::cout << "Error: Email is invalid!\n";
+		std::cout << "Error: Email is invalid!";
 		util::pressEnter();
 		return;
 	}
@@ -192,15 +162,64 @@ void CustomerMenu::updateDetails()
 	util::read(phone);
 	if (!util::isPhoneNumberValid(phone))
 	{
-		std::cout << "Error: Phone number is invalid!\n";
+		std::cout << "Error: Phone number is invalid!";
 		util::pressEnter();
 		return;
 	}
 	m_controller.updateUserDetails(email, phone);
-	std::cout << "Profile details updated successfully\n";
+	std::cout << "Profile details updated successfully";
 	util::pressEnter();
 }
 
+/*
+Function: selectServiceFromServices
+Description: Displays active services and allows the customer to select one by index.
+Parameter: const util::Map<std::string, const Service*>& services - list of services
+Return type: const Service* - selected service
+*/
+static const Service* selectServiceFromServices(const util::Map<std::string, const Service*>& services)
+{
+    util::Map<int, const Service*> activeServicesMap;
+    int currentIndex = 1;
+    int userInputIndex;
+    std::cout << std::left
+        << std::setw(10) << "Index"
+        << std::setw(15) << "Service ID"
+        << std::setw(25) << "Service Name"
+        << std::setw(15) << "Estimated Cost"
+        << std::endl;
+    for (int index = 0; index < services.getSize(); index++)
+    {
+        const Service* currentService = services.getValueAt(index);
+        if (currentService->getState() != util::State::ACTIVE)
+        {
+            continue;
+        }
+        activeServicesMap.insert(currentIndex, currentService);
+        double partsCost = calculatePartsCost(currentService);
+        std::cout << std::left
+            << std::setw(10) << currentIndex
+            << std::setw(15) << currentService->getId()
+            << std::setw(25) << currentService->getName()
+            << std::setw(15) << (currentService->getLaborCost() + partsCost)
+            << std::endl;
+        currentIndex++;
+    }
+    if (activeServicesMap.getSize() == 0)
+    {
+        std::cout << "No active services available." << std::endl;
+        return nullptr;
+    }
+    std::cout << "Enter service index: ";
+    util::read(userInputIndex);
+    if (activeServicesMap.find(userInputIndex) == -1)
+    {
+        std::cout << "Invalid service index." << std::endl;
+        return nullptr;
+    }
+    return activeServicesMap[userInputIndex];
+}
+
 /*
 Function: selectService
 Description: Allows the customer to select a service, provide vehicle details,
@@ -211,16 +230,9 @@ Return type: void
 void CustomerMenu::selectService()
 {
     std::string vehicleNumber, vehicleBrand, vehicleModel;
-    util::clear();
-    std::cout << "Select a Service\n";
 	auto services = m_controller.getServices();
-    if (services.isEmpty())
-    {
-        std::cout << "No services available!";
-        util::pressEnter();
-        return;
-    }
     util::Vector<std::string> selectedServices;
+    util::clear();
     const Service* selectedService = selectServiceFromServices(services);
     if (selectedService == nullptr)
     {
@@ -230,7 +242,6 @@ void CustomerMenu::selectService()
     }
     selectedServices.push_back(selectedService->getId());
     util::clear();
-    std::cout << "Enter Vehicle Details\n";
     std::cout << "Enter vehicle number: ";
     util::read(vehicleNumber);
     std::cout << "Enter vehicle brand: ";
@@ -242,6 +253,54 @@ void CustomerMenu::selectService()
     util::pressEnter();
 }
 
+/*
+Function: selectComboPackageFromPackages
+Description: Displays active combo packages and allows the customer to select one by index.
+Parameter: const util::Map<std::string, const ComboPackage*>& comboPackages - list of combo packages
+Return type: const ComboPackage* - selected combo package
+*/
+static const ComboPackage* selectComboPackageFromPackages(const util::Map<std::string, const ComboPackage*>& comboPackages)
+{
+    util::Map<int, const ComboPackage*> activeComboPackages;
+    int currentIndex = 1;
+    int userInputIndex;
+    std::cout << std::left
+        << std::setw(10) << "Index"
+        << std::setw(15) << "Combo Package ID"
+        << std::setw(15) << "Combo Package Name"
+        << std::setw(15) << "Estimate Cost"
+        << std::endl;
+    for (int index = 0; index < comboPackages.getSize(); index++)
+    {
+        const ComboPackage* currentComboPackage = comboPackages.getValueAt(index);
+        if (currentComboPackage->getState() != util::State::ACTIVE)
+        {
+            continue;
+        }
+        activeComboPackages.insert(currentIndex, currentComboPackage);
+        std::cout << std::left
+            << std::setw(10) << currentIndex
+            << std::setw(15) << currentComboPackage->getId()
+            << std::setw(25) << currentComboPackage->getPackageName()
+            << std::setw(15) << calculateComboServiceEstimatedCost(currentComboPackage)
+            << std::endl;
+        currentIndex++;
+    }
+    if (activeComboPackages.getSize() == 0)
+    {
+        std::cout << "No active combo packages available." << std::endl;
+        return nullptr;
+    }
+    std::cout << "Enter combo package index: ";
+    util::read(userInputIndex);
+    if (activeComboPackages.find(userInputIndex) == -1)
+    {
+        std::cout << "Invalid combo package index." << std::endl;
+        return nullptr;
+    }
+    return activeComboPackages[userInputIndex];
+}
+
 /*
 Function: selectComboPackage
 Description: Allows the customer to select a combo package, provide vehicle details,
@@ -252,27 +311,16 @@ Return type: void
 void CustomerMenu::selectComboPackage()
 {
     std::string vehicleNumber, vehicleBrand, vehicleModel;
-    util::clear();
-    std::cout << "Select a Combo Package\n";
     auto comboPackages = m_controller.getComboPackages();
-    util::Map<std::string, const ComboPackage*> activeComboPackages = filterComboPackages(comboPackages);
-    if (activeComboPackages.isEmpty())
-    {
-        std::cout << "No combo packages available!\n\n";
-        util::pressEnter();
-        return;
-    }
-    const ComboPackage* selectedComboPackage = selectComboPackageFromPackages(activeComboPackages);
+    util::clear();
+    const ComboPackage* selectedComboPackage = selectComboPackageFromPackages(comboPackages);
     if (selectedComboPackage == nullptr)
     {
-        std::cout << "Failed to book combo package!\n\n";
+        std::cout << "Failed to book combo package!";
         util::pressEnter();
         return;
     }
-    std::cout << "Combo Package selected\n";
-    util::pressEnter();
     util::clear();
-    std::cout << "Enter the vehicle details\n";
     std::cout << "Enter vehicle number: ";
     util::read(vehicleNumber);
     std::cout << "Enter vehicle brand: ";
@@ -280,167 +328,20 @@ void CustomerMenu::selectComboPackage()
     std::cout << "Enter vehicle model: ";
     util::read(vehicleModel);
     m_controller.purchaseComboPackage(selectedComboPackage->getId(), vehicleNumber, vehicleBrand, vehicleModel);
-    std::cout << "Combo Package has been booked successfully\n\n";
+    std::cout << "Combo Package has been booked successfully";
     util::pressEnter();
 }
 
-/*
-Function: viewServiceHistory
-Description: Displays the customer’s past service bookings in tabular format,
-             including booking ID, technician, vehicle details, discount percentage, and status.
-Parameters:
-    - None
-Returns:
-    - void
-*/
 void CustomerMenu::viewServiceHistory()
 {
-	util::clear();
-	bool hasServiceHistory = false;
-	const User* currentUser = m_controller.getAuthenticatedUser();
-	std::string currentUserID = currentUser->getId();
-	util::Map<std::string, const ServiceBooking*> serviceBookingsByCurrentUser = m_controller.getServiceBookingsByUser(currentUserID);
-    std::cout << "View Service History" << std::endl;
-    if (serviceBookingsByCurrentUser.getSize() != 0)
-    {
-        std::cout << std::left
-            << std::setw(15) << "Booking ID"
-            << std::setw(20) << "Technician"
-            << std::setw(20) << "Vehicle Brand"
-            << std::setw(20) << "Vehicle Number"
-            << std::setw(20) << "Vehicle Model"
-            << std::setw(20) << "Discount %"
-            << std::setw(20) << "Status"
-            << std::endl;
-        for (int iterator = 0; iterator < serviceBookingsByCurrentUser.getSize(); iterator++)
-        {
-            const ServiceBooking* currentBooking = serviceBookingsByCurrentUser.getValueAt(iterator);
-            std::string technicianName = currentBooking->getAssignedTechnician() == nullptr
-                ? "Not Assigned"
-                : currentBooking->getAssignedTechnician()->getName();
-            std::cout << std::left
-                << std::setw(15) << currentBooking->getId()
-                << std::setw(20) << technicianName
-                << std::setw(20) << currentBooking->getVehicleBrand()
-                << std::setw(20) << currentBooking->getVehicleNumber()
-                << std::setw(20) << currentBooking->getVehicleModel()
-                << std::setw(20) << currentBooking->getDiscountPercentage()
-                << std::setw(20) << util::getServiceJobStatusString(currentBooking->getStatus())
-                << std::endl;
-            hasServiceHistory = true;
-        }
-    }
-    if (!hasServiceHistory)
-    {
-        std::cout << "No history available." << std::endl;
-    }
-    util::pressEnter();
 }
 
-/*
-Function: cancelServiceBooking
-Description: Allows the customer to cancel a pending service booking.
-             Displays the list of active bookings, lets the user select one,
-             and removes it from the system. If no bookings are available,
-             an appropriate message is shown.
-Parameter: None
-Return type: void
-*/
-void CustomerMenu::cancelServiceBooking()
-{
-    util::clear();
-    std::cout << "Cancel Service Booking\n";
-    const User* currentUser = m_controller.getAuthenticatedUser();
-    std::string currentUserID = currentUser->getId();
-    util::Map<std::string, const ServiceBooking*> serviceBookingsByCurrentUser = m_controller.getServiceBookingsByUser(currentUserID);
-    util::Map<int, const ServiceBooking*> serviceBookingsMap;
-    auto currentPendingServiceBookings = filterActiveServiceBookings(serviceBookingsByCurrentUser);
-    int bookingsSize = currentPendingServiceBookings.getSize();
-    if (listServiceBookings(currentPendingServiceBookings, bookingsSize, serviceBookingsMap))
-    {
-        const ServiceBooking* selectedService = selectPendingServiceBookings(serviceBookingsMap);
-        if (selectedService)
-        {
-            m_controller.removeServiceBooking(selectedService->getId());
-            std::cout << "Cancelled Service booking of id " + selectedService->getId() << std::endl << std::endl;
-        }
-        else
-        {
-            std::cout << "Invalid service booking index.\n\n";
-            return;
-        }
-    }
-    else
-    {
-        std::cout << "No pending service bookings available.\n\n";
-    }
-    util::pressEnter();
-}
-
-/*
-Function: completePayments
-Description: Allows the customer to complete pending payments for invoices.
-             Validates invoice selection and payment mode before completing payment.
-Parameters:
-    - None
-Returns:
-    - void
-*/
 void CustomerMenu::completePayments()
 {
-	util::clear();
-    std::cout << "Complete Payments\n";
-	util::Map<std::string, const Invoice*> currentInvoices = m_controller.getInvoicesByUser();
-    if (currentInvoices.isEmpty())
-    {
-        std::cout << "No pending invoices available for payment.\n";
-        util::pressEnter();
-        return;
-    }
-    bool hasPending = false;
-    for (int index = 0; index < currentInvoices.getSize(); ++index)
-    {
-        const Invoice* invoice = currentInvoices.getValueAt(index);
-        if (invoice && invoice->getStatus() == util::PaymentStatus::PENDING)
-        {
-            hasPending = true;
-            break;
-        }
-    }
-    if (!hasPending)
-    {
-        std::cout << "No pending invoices available for payment.\n";
-        util::pressEnter();
-        return;
-    }
-	std::string selectedID = selectInvoiceFromUserForPayment(currentInvoices, util::PaymentStatus::PENDING);
-    if (selectedID == "")
-    {
-        std::cout << "Payment failed.\n";
-        util::pressEnter();
-        return;
-    }
-    util::PaymentMode paymentMode = selectPaymentMode();
-    m_controller.completePayment(selectedID, paymentMode);
-    std::cout << "Payment completed successfully.\n";
-    util::pressEnter();
 }
 
-/*
-Function: viewInvoices
-Description: Displays invoices associated with the customer by calling displayInvoices.
-Parameters:
-    - None
-Returns:
-    - void
-*/
 void CustomerMenu::viewInvoices()
 {
-	util::clear();
-    std::cout << "View Invoices\n";
-	util::Map<std::string, const Invoice*> currentUserInvoices = m_controller.getInvoicesByUser();
-	displayInvoices(currentUserInvoices);
-    util::pressEnter();
 }
 
 /*
@@ -456,6 +357,38 @@ void CustomerMenu::viewNotifications()
 	viewAndDeleteNotification(m_controller);
 }
 
+/*
+Function: getNotificationPreference (static helper)
+Description: Helper function to configure notification preferences for a specific service.
+Parameters:
+    - serviceName: Name of the service for which notifications are being configured.
+Returns:
+    - bool: True if notifications are enabled, False if disabled.
+*/
+static bool getNotificationPreference(const std::string& serviceName)
+{
+    int choice;
+    while (true)
+    {
+        util::clear();
+        std::cout << "    Configure Notification Preferences\n";
+        std::cout << "\n" << serviceName << " Notifications\n";
+        std::cout << "1. Enable Notifications\n";
+        std::cout << "2. Disable Notifications\n";
+        std::cout << "Enter your choice: ";
+        util::read(choice);
+        if (choice == 1)
+        {
+            return true;
+        }
+        if (choice == 2)
+        {
+            return false;
+        }
+        std::cout << "\nInvalid choice. Please enter 1 or 2.\n";
+        util::pressEnter();
+    }
+}
 
 /*
 Function: configureNotifications

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/CustomerMenu.h

@@ -7,16 +7,14 @@ Description: Header file declaring the CustomerMenu class, which provides
 Author: Trenser
 Date:19-May-2026
 */
-
 #pragma once
-#include "Menu.h"
 #include "Controller.h"
 
-class CustomerMenu : public Menu
+class CustomerMenu
 {
 private:
+    Controller m_controller;
     bool handleOperation(int choice);
-    void handleNotificationEvent();
 public:
     void showMenu();
     void logout();
@@ -28,6 +26,5 @@ public:
     void completePayments();
     void viewInvoices();
     void viewNotifications();
-    void cancelServiceBooking();
     void configureNotifications();
 };

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/Menu.cpp

@@ -1,150 +0,0 @@
-/*
-File: Menu.cpp
-Description: Implementation file containing common menu event listener
-             functionality, account disable handling, and notification
-             event dispatching for all menu types.
-Author: Trenser
-Date:16-Jun-2026
-*/
-
-#include "Menu.h"
-
-/*
-Function: Menu
-Description: Constructs a Menu object and initializes event handles
-             and menu state.
-Parameter: None
-Return type: None
-*/
-Menu::Menu()
-    :
-    m_isMenuActive(false),
-    m_accountDisabledEvent(NULL),
-    m_notificationAvailableEvent(NULL),
-    m_shutdownEvent(NULL) {}
-
-/*
-Function: ~Menu
-Description: Destroys the Menu object and performs event listener
-             cleanup.
-Parameter: None
-Return type: None
-*/
-Menu::~Menu()
-{
-    stopEventListener();
-}
-
-/*
-Function: startEventListener
-Description: Creates menu event handles, registers them with the
-             authentication service, and starts the event listener
-             thread.
-Parameter: None
-Return type: void
-*/
-void Menu::startEventListener()
-{
-    if (m_isMenuActive.load())
-    {
-        return;
-    }
-    m_isMenuActive.store(true);
-    m_accountDisabledEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
-    m_notificationAvailableEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
-    m_shutdownEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
-    m_controller.registerEvents(m_accountDisabledEvent, m_notificationAvailableEvent);
-    m_eventListenerThread = std::thread(&Menu::eventListenerLoop, this);
-}
-
-/*
-Function: eventListenerLoop
-Description: Waits for account disabled, notification available,
-             and shutdown events and dispatches them to the
-             appropriate handlers.
-Parameter: None
-Return type: void
-*/
-void Menu::eventListenerLoop()
-{
-    HANDLE handles[3];
-    handles[0] = m_accountDisabledEvent;
-    handles[1] = m_notificationAvailableEvent;
-    handles[2] = m_shutdownEvent;
-    while (m_isMenuActive.load())
-    {
-        DWORD result = WaitForMultipleObjects(3, handles, FALSE, INFINITE);
-        switch (result)
-        {
-        case WAIT_OBJECT_0:
-            handleAccountDisabledEvent();
-            break;
-        case WAIT_OBJECT_0 + 1:
-            handleNotificationEvent();
-            break;
-        case WAIT_OBJECT_0 + 2:
-            return;
-        }
-    }
-}
-
-/*
-Function: stopEventListener
-Description: Stops the event listener thread and releases all
-             associated event handles.
-Parameter: None
-Return type: void
-*/
-void Menu::stopEventListener()
-{
-    m_isMenuActive.store(false);
-    if (m_shutdownEvent)
-    {
-        SetEvent(m_shutdownEvent);
-    }
-    if (m_eventListenerThread.joinable())
-    {
-        m_eventListenerThread.join();
-    }
-    if (m_accountDisabledEvent)
-    {
-        CloseHandle(m_accountDisabledEvent);
-    }
-    if (m_notificationAvailableEvent)
-    {
-        CloseHandle(m_notificationAvailableEvent);
-    }
-    if (m_shutdownEvent)
-    {
-        CloseHandle(m_shutdownEvent);
-    }
-    m_accountDisabledEvent = NULL;
-    m_notificationAvailableEvent = NULL;
-    m_shutdownEvent = NULL;
-}
-
-/*
-Function: handleAccountDisabledEvent
-Description: Handles an account disabled event by marking the menu
-             inactive and notifying the user.
-Parameter: None
-Return type: void
-*/
-void Menu::handleAccountDisabledEvent()
-{
-    m_isMenuActive.store(false);
-    const User* authenticatedUser = m_controller.getAuthenticatedUser();
-    std::string messageTitle = "Account Disabled";
-    if (authenticatedUser)
-    {
-        messageTitle += " - " + authenticatedUser->getName();
-    }
-    MessageBoxA(
-        GetConsoleWindow(),
-        "Your account has been disabled.",
-        messageTitle.c_str(),
-        MB_OK |
-        MB_ICONWARNING |
-        MB_SETFOREGROUND |
-        MB_TOPMOST);
-}

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/Menu.h

@@ -1,33 +0,0 @@
-/*
-File: Menu.h
-Description: Base class providing common event listener functionality
-             for all menu implementations.
-Author: Trenser
-Date:16-Jun-2026
-*/
-
-#pragma once
-
-#include <windows.h>
-#include <atomic>
-#include <thread>
-#include "Controller.h"
-
-class Menu
-{
-protected:
-    Controller m_controller;
-    std::atomic<bool> m_isMenuActive;
-    HANDLE m_accountDisabledEvent;
-    HANDLE m_notificationAvailableEvent;
-    HANDLE m_shutdownEvent;
-    std::thread m_eventListenerThread;
-    void startEventListener();
-    void stopEventListener();
-    void eventListenerLoop();
-    void handleAccountDisabledEvent();
-    virtual void handleNotificationEvent() = 0;
-public:
-    Menu();
-    virtual ~Menu();
-};

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

@@ -1,20 +1,16 @@
 /*
 File: TechnicianMenu.cpp
-Description: Implementation file containing the method definitions of the
-             TechnicianMenu class, including menu handling, job completion,
-             notification viewing, password management, and logout logic.
+Description: Implements the TechnicianMenu class which provides the technician’s console interface
+			 in the Vehicle Service Management System. Handles menu display, user input, and
+			 technician-specific operations such as completing jobs and viewing notifications.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
 
-#include "Enums.h"
-#include "InputHelper.h"
-#include "JobCard.h"
-#include "MenuHelper.h"
-#include "OutputHelper.h"
-#include "Service.h"
 #include "TechnicianMenu.h"
-#include "Validator.h"
+#include "InputHelper.h"
+#include "OutputHelper.h"
+#include "MenuHelper.h"
 
 /*
 Function: showMenu
@@ -27,29 +23,18 @@ Returns:
 */
 void TechnicianMenu::showMenu()
 {
-    startEventListener();
-    while (true)
+	bool isMenuActive = true;
+	while (isMenuActive)
 	{
 		try
 		{
-            if (!m_isMenuActive)
-            {
-                logout();
-                break;
-            }
 			int choice;
 			util::clear();
-            std::cout << "Technician Menu"
-                << "\n1. Display My Jobs"
-                << "\n2. Update Job Status"
-                << "\n3. View Notifications"
-                << "\n4. Change Password"
-                << "\n5. Logout"
-                << "\nEnter a choice: ";
+			std::cout << "" << std::endl;
 			util::read(choice);
 			if (!handleOperation(choice))
 			{
-                break;
+				isMenuActive = false;
 			}
 		}
 		catch (const std::exception& e)
@@ -58,124 +43,15 @@ void TechnicianMenu::showMenu()
 			util::pressEnter();
 		}
 	}
-    stopEventListener();
 }
 
-/*
-Function: handleOperation
-Description: Executes the corresponding technician operation based on the selected menu choice.
-Parameter: int choice - selected menu option
-Return type: bool - true if menu continues, false if logout
-*/
 bool TechnicianMenu::handleOperation(int choice)
 {
-    if (!m_isMenuActive)
-    {
-        logout();
 	return false;
-    }
-    switch (choice)
-    {
-    case 1:
-        displayJobs();
-        break;
-    case 2:
-        updateJobStatus();
-        break;
-    case 3:
-        viewNotifications();
-        break;
-    case 4:
-        changePassword();
-        break;
-    case 5:
-        logout();
-        return false;
-    default:
-        std::cout << "Enter a valid choice!" << std::endl;
-        util::pressEnter();
-    }
-    return true;
 }
 
-/*
-Function: handleNotificationEvent
-Description: Retrieves and displays the latest notification for the
-             currently logged in admin.
-Parameter: None
-Return type: void
-*/
-void TechnicianMenu::handleNotificationEvent()
+void TechnicianMenu::completeJob()
 {
-    auto notifications = m_controller.getNotifications();
-    const User* authenticatedUser = m_controller.getAuthenticatedUser();
-    std::string name;
-    if (authenticatedUser)
-    {
-        name = authenticatedUser->getName();
-    }
-    displayNewNotification(notifications, name);
-}
-
-/*
-Function: displayJobs
-Description: Displays all Jobs assigned to a Technician
-Parameters:
-    - None
-Returns:
-    - void
-*/
-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*> jobCards = filterStartedJobCards(assignedJobCards);
-    displayAllJobs(jobCards);
-    util::pressEnter();
-}
-
-/*
-Function: updateJobStatus
-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::updateJobStatus()
-{
-    util::clear();
-    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();
-    std::cout << "Select the type of job you want to update:\n1.Started\n2.In Progress\nChoice: ";
-    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.updateJobStatus(selectedJobID);
-		std::cout << "\nJob status updated.\n\n";
-	}
-    util::pressEnter();
 }
 
 /*
@@ -190,26 +66,3 @@ void TechnicianMenu::viewNotifications()
 {
 	viewAndDeleteNotification(m_controller);
 }
-
-/*
-Function: logout
-Description: Logs out the currently authenticated technician user.
-Parameter: None
-Return type: void
-*/
-void TechnicianMenu::logout()
-{
-	m_controller.logout();
-}
-
-/*
-Function: changePassword
-Description: Allows the technician to change their password after validation.
-Parameter: None
-Return type: void
-*/
-
-void TechnicianMenu::changePassword()
-{
-    changePasswordHelper(m_controller);
-}

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

@@ -1,26 +1,21 @@
 /*
 File: TechnicianMenu.h
-Description: Header file declaring the TechnicianMenu class, which provides
-             technician operations such as job completion, notification viewing,
-             password management, and logout functionality.
+Description: Declares the TechnicianMenu class which provides the technician-facing console menu in the Vehicle Service Management System.
+             Supports operations such as viewing assigned jobs, completing jobs, and managing notifications.
 Author: Trenser
-Date:19-May-2026
+Date: 19-May-2026
 */
 
 #pragma once
 #include "Controller.h"
-#include "Menu.h"
 
-class TechnicianMenu : public Menu
+class TechnicianMenu
 {
 private:
+    Controller m_controller;
     bool handleOperation(int choice);
-    void handleNotificationEvent();
 public:
     void showMenu();
-    void displayJobs();
-    void updateJobStatus();
+    void completeJob();
     void viewNotifications();
-    void logout();
-    void changePassword();
 };

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

@@ -6,14 +6,11 @@ Description: Implementation file containing the method definitions of the
 Author: Trenser
 Date:19-May-2026
 */
-
-#include <iostream>
-#include <stdexcept>
-#include "Enums.h"
+#include "UserInterface.h"
 #include "InputHelper.h"
 #include "OutputHelper.h"
+#include "Enums.h"
 #include "User.h"
-#include "UserInterface.h"
 #include "Validator.h"
 
 /*
@@ -25,13 +22,8 @@ Return type: void
 */
 void UserInterface::run()
 {
-	try
-	{
-		if (!m_controller.initialize())
-		{
-			std::cout << "Error: Failed to initialize the system!";
-			return;
-		}
+	m_controller.loadSystemData();
+	m_controller.runSystemChecks();
 	bool isMenuActive = true;
 	while (isMenuActive)
 	{
@@ -52,20 +44,7 @@ void UserInterface::run()
 			util::pressEnter();
 		}
 	}
-		m_controller.shutdown();
-	}
-	catch (const std::invalid_argument& exception)
-	{
-		std::cout << "Exception: Invalid Argument: " << exception.what() << std::endl;
-	}
-	catch (const std::exception& exception)
-	{
-		std::cout << "Exception: " << exception.what() << std::endl;
-	}
-	catch (...)
-	{
-		std::cout << "Unknown error occurred." << std::endl;
-	}
+	m_controller.saveSystemData();
 }
 
 /*
@@ -105,15 +84,14 @@ void UserInterface::login()
 {
 	std::string username, password;
 	util::clear();
-	std::cout << "Login\n";
 	std::cout << "Enter username: ";
 	util::read(username);
 	std::cout << "Enter password: ";
-	util::readPassword(password);
+	util::read(password);
 	if (m_controller.login(username, password))
 	{
 		const User* authenticatedUser = m_controller.getAuthenticatedUser();
-		if (authenticatedUser && authenticatedUser->getState() != util::State::INACTIVE)
+		if (authenticatedUser != nullptr)
 		{
 			switch (authenticatedUser->getUserType())
 			{
@@ -131,16 +109,10 @@ void UserInterface::login()
 				break;
 			}
 		}
-		else if (authenticatedUser && authenticatedUser->getState() == util::State::INACTIVE)
-		{
-			std::cout << "\nError: Your account has been disabled. Please contact your Administrator.";
-			util::pressEnter();
-		}
 	}
 	else
 	{
 		std::cout << "\nError: Invalid Username or Password";
-		util::pressEnter();
 	}
 }
 
@@ -156,7 +128,6 @@ void UserInterface::registerCustomer()
 {
 	std::string username, name, email, phone, password;
 	util::clear();
-	std::cout << "Register Customer\n";
 	std::cout << "Enter username: ";
 	util::read(username);
 	std::cout << "Enter name: ";
@@ -170,7 +141,7 @@ void UserInterface::registerCustomer()
 		return;
 	}
 	std::cout << "Enter password: ";
-	util::readPassword(password);
+	util::read(password);
 	if (!util::isPasswordValid(password))
 	{
 		std::cout << "Error: Password is invalid!";

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/views/UserInterface.h

@@ -7,7 +7,6 @@ Description: Header file declaring the UserInterface class, which provides
 Author: Trenser
 Date:19-May-2026
 */
-
 #pragma once
 #include "Controller.h"
 #include "AdminMenu.h"