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

2026-05-25 12:33:15 +05:30
parent 72860edd18 014d4eaa0d
commit 28e4b17c63
40 changed files with 2360 additions and 72 deletions
@@ -1,12 +1,24 @@
+/*
+File: InventoryManagementService.cpp
+Description: Implements the InventoryManagementService class, which manages inventory
+			 items and observer relationships within the system. Provides methods
+			 for loading and saving inventory items from persistent storage, as well
+			 as attaching and persisting observers for notification handling.
+Author: Trenser
+Date: 22-May-2026
+*/
+
 #include <stdexcept>
-#include "InventoryManagementService.h"
-#include "Vector.h"
-#include "Enums.h"
-#include "InventoryItem.h"
 #include "Config.h"
-#include "User.h"
+#include "Enums.h"
 #include "Factory.h"
+#include "FileManager.h"
+#include "InventoryItem.h"
+#include "InventoryManagementService.h"
 #include "Timestamp.h"
+#include "User.h"
+#include "Utility.h"
+#include "Vector.h"

 util::Map<std::string, User*> InventoryManagementService::m_observers{};

@@ -103,3 +115,93 @@ void InventoryManagementService::sendLowStockAlerts()
 		}
 	}
 }
+
+
+/*
+Function: getObserverIDs
+Description: Retrieves the IDs of all observers currently attached to the
+			 InventoryManagementService.
+Parameters:
+	- None
+Returns:
+	- util::Vector<std::string>: Vector of observer user IDs
+*/
+util::Vector<std::string> InventoryManagementService::getObserverIDs()
+{
+	util::Vector<std::string> observerIDs;
+	int numberOfObservers = m_observers.getSize();
+	for (int index = 0; index < numberOfObservers; index++)
+	{
+		User* observer = m_observers.getValueAt(index);
+		if (observer)
+		{
+			observerIDs.push_back(observer->getId());
+		}
+	}
+	return observerIDs;
+}
+
+/*
+Function: loadInventoryItems
+Description: Loads inventory items from persistent storage into the datastore.
+			 Uses FileManager to deserialize inventory items from the configured file.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void InventoryManagementService::loadInventoryItems()
+{
+	util::FileManager<InventoryItem> inventoryItemFileManager(config::file::INVENTORYITEM_FILE);
+	auto& inventoryItems = m_dataStore.getInventoryItems();
+	auto inventoryItemsMap = inventoryItemFileManager.load();
+	int numberOfInventoryItems = inventoryItemsMap.getSize();
+	for (int index = 0; index < numberOfInventoryItems; index++)
+	{
+		inventoryItems[inventoryItemsMap.getKeyAt(index)] = inventoryItemsMap.getValueAt(index);
+	}
+}
+
+/*
+Function: saveInventoryItems
+Description: Saves inventory items from the datastore to persistent storage.
+			 Uses FileManager to serialize inventory items into the configured file.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void InventoryManagementService::saveInventoryItems()
+{
+	util::FileManager<InventoryItem> inventoryItemFileManager(config::file::INVENTORYITEM_FILE);
+	auto& inventoryItems = m_dataStore.getInventoryItems();
+	inventoryItemFileManager.save(inventoryItems);
+}
+
+/*
+Function: loadObservers
+Description: Loads observer IDs from persistent storage and attaches corresponding
+			 users as observers to the InventoryManagementService.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void InventoryManagementService::loadObservers()
+{
+	util::loadObservers(config::file::INVENTORYMANAGEMENTOBSERVERS, this, m_dataStore);
+}
+
+/*
+Function: saveObservers
+Description: Saves the current observer IDs of the InventoryManagementService
+			 to persistent storage for future retrieval.
+Parameters:
+	- None
+Returns:
+	- void
+*/
+void InventoryManagementService::saveObservers()
+{
+	util::saveObservers(config::file::INVENTORYMANAGEMENTOBSERVERS, this);
+}
@@ -9,6 +9,7 @@ Date: 19-May-2026
 #pragma once
 #include <string>
 #include "Map.h"
+#include "Vector.h"
 #include "NotificationManagementService.h"
 #include "DataStore.h"

@@ -19,6 +20,7 @@ class InventoryManagementService : public NotificationManagementService
 private:
    DataStore& m_dataStore;
    static util::Map<std::string, User*> m_observers;
+    util::Vector<std::string> getObserverIDs() override;
 public:
    InventoryManagementService() : m_dataStore(DataStore::getInstance()) {}
    util::Map<std::string, InventoryItem*> getInventoryItems();
@@ -29,4 +31,8 @@ public:
    void sendNotification(User* user, const std::string& title, const std::string& message) override;
    void attach(User* user) override;
    void detach(User* user) override;
+    void loadInventoryItems();
+    void saveInventoryItems();
+    void loadObservers();
+    void saveObservers();
 };
@@ -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;
 };
@@ -8,14 +8,17 @@ Date: 20-May-2026
 */

 #include <stdexcept>
-#include "PaymentManagementService.h"
-#include "Invoice.h"
-#include "ServiceBooking.h"
-#include "Enums.h"
-#include "Timestamp.h"
 #include "Config.h"
-#include "User.h"
+#include "Enums.h"
 #include "Factory.h"
+#include "FileManager.h"
+#include "Invoice.h"
+#include "PaymentManagementService.h"
+#include "ServiceBooking.h"
+#include "Timestamp.h"
+#include "User.h"
+#include "Utility.h"
+

 util::Map<std::string, User*> PaymentManagementService::m_observers{};

@@ -134,3 +137,120 @@ void PaymentManagementService::sendPaymentReminders()
 		}
 	}
 }
+
+/*
+Function: getObserverIDs
+Description: Retrieves the IDs of all observers currently attached to the
+             PaymentManagementService.
+Parameters:
+    - None
+Returns:
+    - util::Vector<std::string>: Vector of observer user IDs
+*/
+util::Vector<std::string> PaymentManagementService::getObserverIDs()
+{
+	util::Vector<std::string> observerIDs;
+	int numberOfObservers = m_observers.getSize();
+	for (int index = 0; index < numberOfObservers; index++)
+	{
+		User* observer = m_observers.getValueAt(index);
+		if (observer)
+		{
+			observerIDs.push_back(observer->getId());
+		}
+	}
+	return observerIDs;
+}
+
+/*
+Function: loadInvoices
+Description: Loads invoices from persistent storage into the datastore.
+             Validates associated service bookings and inventory parts before
+             attaching them to each invoice. Throws exceptions if invalid IDs
+             are encountered.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a booking ID or part ID is invalid
+*/
+void PaymentManagementService::loadInvoices()
+{
+    util::FileManager<Invoice> invoiceFileManager(config::file::INVOICE_FILE);
+    auto& invoices = m_dataStore.getInvoices();
+    auto& serviceBookings = m_dataStore.getServiceBookings();
+    auto& inventoryItems = m_dataStore.getInventoryItems();
+    auto invoicesMap = invoiceFileManager.load();
+    for (int invoiceIndex = 0; invoiceIndex < invoicesMap.getSize(); invoiceIndex++)
+    {
+        Invoice* invoice = invoicesMap.getValueAt(invoiceIndex);
+        int bookingIndex = serviceBookings.find(invoice->getBookingId());
+        if (bookingIndex == -1)
+        {
+            throw std::runtime_error("Invalid Booking ID");
+        }
+        ServiceBooking* booking = serviceBookings.getValueAt(bookingIndex);
+        invoice->setBooking(booking);
+        util::Map<std::string, InventoryItem*> invoiceParts;
+        auto& partIDs = invoice->getPartIDs();
+        for (int partIndex = 0; partIndex < partIDs.getSize(); partIndex++)
+        {
+            const std::string& partID = partIDs[partIndex];
+            int inventoryIndex = inventoryItems.find(partID);
+            if (inventoryIndex == -1)
+            {
+                throw std::runtime_error("Invalid Part ID");
+            }
+            invoiceParts[partID] = inventoryItems.getValueAt(inventoryIndex);
+        }
+        invoice->setParts(invoiceParts);
+        invoices[invoice->getId()] = invoice;
+    }
+}
+
+/*
+Function: saveInvoices
+Description: Saves invoices from the datastore to persistent storage.
+             Uses FileManager to serialize invoices into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void PaymentManagementService::saveInvoices()
+{
+    util::FileManager<Invoice> invoiceFileManager(config::file::INVOICE_FILE);
+    auto& invoices = m_dataStore.getInvoices();
+    invoiceFileManager.save(invoices);
+}
+
+/*
+Function: loadObservers
+Description: Loads observer IDs from persistent storage and attaches corresponding
+             users as observers to the PaymentManagementService.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if an observer ID is invalid (not found in datastore)
+*/
+void PaymentManagementService::loadObservers()
+{
+    util::loadObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this, m_dataStore);
+}
+
+/*
+Function: saveObservers
+Description: Saves the current observer IDs of the PaymentManagementService
+             to persistent storage for future retrieval.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void PaymentManagementService::saveObservers()
+{
+    util::saveObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this);
+}
@@ -22,6 +22,7 @@ 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);
@@ -31,4 +32,8 @@ public:
    void sendNotification(User* user, const std::string& title, const std::string& message) override;
    void attach(User* user) override;
    void detach(User* user) override;
+    void loadInvoices();
+    void saveInvoices();
+    void loadObservers();
+    void saveObservers();
 };
@@ -6,15 +6,20 @@ Description: Implementation file containing the method definitions of the
 Author: Trenser
 Date:19-May-2026
 */
+
 #include <stdexcept>
 #include "AuthenticationManagementService.h"
 #include "ComboPackage.h"
+#include "Config.h"
 #include "Factory.h"
+#include "FileManager.h"
+#include "JobCard.h"
 #include "Service.h"
 #include "ServiceBooking.h"
 #include "ServiceManagementService.h"
 #include "Timestamp.h"
 #include "User.h"
+#include "Utility.h"

 /*
 Function: purchaseService
@@ -178,3 +183,320 @@ void ServiceManagementService::sendNotification(User* user, const std::string& t
 		}
 	}
 }
+
+/*
+Function: getObserverIDs
+Description: Retrieves the IDs of all observers currently attached to the
+             ServiceManagementService.
+Parameters:
+    - None
+Returns:
+    - util::Vector<std::string>: Vector of observer user IDs
+*/
+util::Vector<std::string> ServiceManagementService::getObserverIDs()
+{
+	util::Vector<std::string> observerIDs;
+	int numberOfObservers = m_observers.getSize();
+	for (int index = 0; index < numberOfObservers; index++)
+	{
+		User* observer = m_observers.getValueAt(index);
+		if (observer)
+		{
+			observerIDs.push_back(observer->getId());
+		}
+	}
+	return observerIDs;
+}
+
+/*
+Function: loadServices
+Description: Loads services from persistent storage into the datastore.
+             Validates required inventory items and attaches them to each service.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if an inventory item ID is invalid
+*/
+void ServiceManagementService::loadServices()
+{
+    util::FileManager<Service> serviceFileManager(config::file::SERVICE_FILE);
+    auto& services = m_dataStore.getServices();
+    auto& inventoryItems = m_dataStore.getInventoryItems();
+    auto servicesMap = serviceFileManager.load();
+    for (int serviceIndex = 0; serviceIndex < servicesMap.getSize(); serviceIndex++)
+    {
+        Service* service = servicesMap.getValueAt(serviceIndex);
+        services[service->getId()] = service;
+        util::Map<std::string, InventoryItem*> inventoryItemsMap;
+        auto& inventoryItemIDs = service->getRequiredInventoryItemIDs();
+        for (int inventoryItemIndex = 0; inventoryItemIndex < inventoryItemIDs.getSize(); inventoryItemIndex++)
+        {
+            const std::string& inventoryItemID = inventoryItemIDs[inventoryItemIndex];
+            int index = inventoryItems.find(inventoryItemID);
+            if (index == -1)
+            {
+                throw std::runtime_error("Invalid Inventory Item ID");
+            }
+            inventoryItemsMap[inventoryItemID] = inventoryItems.getValueAt(index);
+        }
+        service->setRequiredInventoryItems(inventoryItemsMap);
+    }
+}
+
+/*
+Function: saveServices
+Description: Saves services from the datastore to persistent storage.
+             Uses FileManager to serialize services into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void ServiceManagementService::saveServices()
+{
+	util::FileManager<Service> serviceFileManager(config::file::SERVICE_FILE);
+	auto& services = m_dataStore.getServices();
+	serviceFileManager.save(services);
+}
+
+/*
+Function: loadComboPackages
+Description: Loads combo packages from persistent storage into the datastore.
+             Validates associated services and attaches them to each package.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a service ID is invalid
+*/
+void ServiceManagementService::loadComboPackages()
+{
+    util::FileManager<ComboPackage> comboPackageFileManager(config::file::COMBOPACKAGE_FILE);
+    auto& comboPackages = m_dataStore.getComboPackages();
+    auto& services = m_dataStore.getServices();
+    auto comboPackagesMap = comboPackageFileManager.load();
+    for (int packageIndex = 0; packageIndex < comboPackagesMap.getSize(); packageIndex++)
+    {
+        ComboPackage* comboPackage = comboPackagesMap.getValueAt(packageIndex);
+        util::Map<std::string, Service*> packageServices;
+        auto& serviceIDs = comboPackage->getServiceIDs();
+        for (int serviceIndex = 0; serviceIndex < serviceIDs.getSize(); serviceIndex++)
+        {
+            const std::string& serviceID = serviceIDs[serviceIndex];
+            int serviceMapIndex = services.find(serviceID);
+            if (serviceMapIndex == -1)
+            {
+                throw std::runtime_error("Invalid Service ID");
+            }
+            packageServices[serviceID] = services.getValueAt(serviceMapIndex);
+        }
+        comboPackage->setServices(packageServices);
+        comboPackages[comboPackage->getId()] = comboPackage;
+    }
+}
+
+/*
+Function: saveComboPackages
+Description: Saves combo packages from the datastore to persistent storage.
+             Uses FileManager to serialize combo packages into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void ServiceManagementService::saveComboPackages()
+{
+    util::FileManager<ComboPackage> comboPackageFileManager(config::file::COMBOPACKAGE_FILE);
+    auto& comboPackages = m_dataStore.getComboPackages();
+    comboPackageFileManager.save(comboPackages);
+}
+
+/*
+Function: loadServiceBookings
+Description: Loads service bookings from persistent storage into the datastore.
+             Validates associated services, customers, and technicians before
+             attaching them to each booking.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a service ID, customer ID, or technician ID is invalid
+    - std::runtime_error if a user is not of the expected type (customer/technician)
+*/
+void ServiceManagementService::loadServiceBookings()
+{
+    util::FileManager<ServiceBooking> bookingFileManager(config::file::SERVICEBOOKING_FILE);
+    auto& serviceBookings = m_dataStore.getServiceBookings();
+    auto& services = m_dataStore.getServices();
+    auto& users = m_dataStore.getUsers();
+    auto bookingsMap = bookingFileManager.load();
+    for (int bookingIndex = 0; bookingIndex < bookingsMap.getSize(); bookingIndex++)
+    {
+        ServiceBooking* booking = bookingsMap.getValueAt(bookingIndex);
+        util::Map<std::string, Service*> bookingServices;
+        auto& serviceIDs = booking->getServiceIDs();
+        for (int serviceIndex = 0; serviceIndex < serviceIDs.getSize(); serviceIndex++)
+        {
+            const std::string& serviceID = serviceIDs[serviceIndex];
+            int serviceMapIndex = services.find(serviceID);
+            if (serviceMapIndex == -1)
+            {
+                throw std::runtime_error("Invalid Service ID");
+            }
+
+            bookingServices[serviceID] = services.getValueAt(serviceMapIndex);
+        }
+        booking->setServices(bookingServices);
+        int customerIndex = users.find(booking->getCustomerId());
+        if (customerIndex == -1)
+        {
+            throw std::runtime_error("Invalid Customer ID");
+        }
+        User* customer = users.getValueAt(customerIndex);
+        if (customer->getUserType() != util::UserType::CUSTOMER)
+        {
+            throw std::runtime_error("User is not a customer");
+        }
+        booking->setCustomer(customer);
+        const std::string& technicianId = booking->getAssignedTechnicianId();
+        if (!technicianId.empty())
+        {
+            int technicianIndex = users.find(technicianId);
+            if (technicianIndex == -1)
+            {
+                throw std::runtime_error("Invalid Technician ID");
+            }
+            User* technician = users.getValueAt(technicianIndex);
+            if (technician->getUserType() != util::UserType::TECHNICIAN)
+            {
+                throw std::runtime_error("User is not a technician");
+            }
+            booking->setAssignedTechnician(technician);
+        }
+        serviceBookings[booking->getId()] = booking;
+    }
+}
+
+/*
+Function: saveServiceBookings
+Description: Saves service bookings from the datastore to persistent storage.
+             Uses FileManager to serialize bookings into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void ServiceManagementService::saveServiceBookings()
+{
+    util::FileManager<ServiceBooking> bookingFileManager(config::file::SERVICEBOOKING_FILE);
+    auto& serviceBookings = m_dataStore.getServiceBookings();
+    bookingFileManager.save(serviceBookings);
+}
+
+/*
+Function: loadJobCards
+Description: Loads job cards from persistent storage into the datastore.
+             Validates associated bookings, services, and technicians before
+             attaching them to each job card.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a booking ID, service ID, or technician ID is invalid
+    - std::runtime_error if a service does not belong to the booking
+    - std::runtime_error if a user is not a technician
+*/
+void ServiceManagementService::loadJobCards()
+{
+    util::FileManager<JobCard> jobCardFileManager(config::file::JOBCARD_FILE);
+    auto& jobCards = m_dataStore.getJobCards();
+    auto& serviceBookings = m_dataStore.getServiceBookings();
+    auto& services = m_dataStore.getServices();
+    auto& users = m_dataStore.getUsers();
+    auto jobCardsMap = jobCardFileManager.load();
+    for (int jobCardIndex = 0; jobCardIndex < jobCardsMap.getSize(); jobCardIndex++)
+    {
+        JobCard* jobCard = jobCardsMap.getValueAt(jobCardIndex);
+        int bookingIndex = serviceBookings.find(jobCard->getBookingId());
+        if (bookingIndex == -1)
+        {
+            throw std::runtime_error("Invalid Booking ID");
+        }
+        ServiceBooking* booking = serviceBookings.getValueAt(bookingIndex);
+        jobCard->setBooking(booking);
+        int serviceIndex = services.find(jobCard->getServiceId());
+        if (serviceIndex == -1)
+        {
+            throw std::runtime_error("Invalid Service ID");
+        }
+        Service* service = services.getValueAt(serviceIndex);
+        if (booking->getServices().find(jobCard->getServiceId()) == -1)
+        {
+            throw std::runtime_error("Service does not belong to booking");
+        }
+        jobCard->setService(service);
+        int technicianIndex = users.find(jobCard->getTechnicianId());
+        if (technicianIndex == -1)
+        {
+            throw std::runtime_error("Invalid Technician ID");
+        }
+        User* technician = users.getValueAt(technicianIndex);
+        if (technician->getUserType() != util::UserType::TECHNICIAN)
+        {
+            throw std::runtime_error("User is not a technician");
+        }
+        jobCard->setTechnician(technician);
+        jobCards[jobCard->getId()] = jobCard;
+    }
+}
+
+/*
+Function: saveJobCards
+Description: Saves job cards from the datastore to persistent storage.
+             Uses FileManager to serialize job cards into the configured file.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void ServiceManagementService::saveJobCards()
+{
+    util::FileManager<JobCard> jobCardFileManager(config::file::JOBCARD_FILE);
+    auto& jobCards = m_dataStore.getJobCards();
+    jobCardFileManager.save(jobCards);
+}
+
+/*
+Function: loadObservers
+Description: Loads observer IDs from persistent storage and attaches corresponding
+             users as observers to the ServiceManagementService.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if an observer ID is invalid (not found in datastore)
+*/
+void ServiceManagementService::loadObservers()
+{
+    util::loadObservers(config::file::SERVICEMANAGEMENTOBSERVERS, this, m_dataStore);
+}
+
+/*
+Function: saveObservers
+Description: Saves the current observer IDs of the ServiceManagementService
+             to persistent storage for future retrieval.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void ServiceManagementService::saveObservers()
+{
+    util::saveObservers(config::file::SERVICEMANAGEMENTOBSERVERS, this);
+}
@@ -22,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();
@@ -42,4 +43,14 @@ public:
    void sendNotification(User* user, const std::string& title, const std::string& message) override;
    void attach(User* user) override;
    void detach(User* user) override;
+    void loadServices();
+    void saveServices();
+    void loadComboPackages();
+    void saveComboPackages();
+    void loadServiceBookings();
+    void saveServiceBookings();
+    void loadJobCards();
+    void saveJobCards();
+    void loadObservers();
+    void saveObservers();
 };
@@ -10,7 +10,9 @@ Date:19-May-2026
 #include "Config.h"
 #include "Enums.h"
 #include "Factory.h"
+#include "FileManager.h"
 #include "InventoryManagementService.h"
+#include "Notification.h"
 #include "PaymentManagementService.h"
 #include "ServiceManagementService.h"
 #include "User.h"
@@ -173,4 +175,72 @@ void UserManagementService::deleteNotification(const std::string& notificationID
 		throw std::runtime_error("No notification found with given NotificationID");
 	}
 	notifications.remove(notificationID);
+}
+
+/*
+Function: loadUsers
+Description: Loads users and notifications from persistent storage into the datastore.
+             Validates that each notification’s recipient exists and attaches the
+             notification to the corresponding user.
+Parameters:
+    - None
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a notification recipient user ID is invalid
+*/
+void UserManagementService::loadUsers()
+{
+    util::FileManager<User> userFileManager(config::file::USER_FILE);
+    util::FileManager<Notification> notificationFileManager(config::file::NOTIFICATION_FILE);
+    auto& users = m_dataStore.getUsers();
+    auto usersMap = userFileManager.load();
+    auto notificationsMap = notificationFileManager.load();
+    int numberOfUsers = usersMap.getSize();
+    int numberOfNotifications = notificationsMap.getSize();
+    for (int index = 0; index < numberOfUsers; index++)
+    {
+        users[usersMap.getKeyAt(index)] = usersMap.getValueAt(index);
+    }
+    for (int index = 0; index < numberOfNotifications; index++)
+    {
+        Notification* notification = notificationsMap.getValueAt(index);
+        const std::string& recipientUserId = notification->getRecipientUserId();
+        int userIndex = users.find(recipientUserId);
+        if (userIndex == -1)
+        {
+            throw std::runtime_error("Invalid recipient user ID");
+        }
+        User* user = users.getValueAt(userIndex);
+        user->addNotification(notification);
+    }
+}
+
+/*
+Function: saveUsers
+Description: Saves users and their notifications from the datastore to persistent storage.
+             Collects notifications from all users into a single map before saving.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void UserManagementService::saveUsers()
+{
+    util::FileManager<User> userFileManager(config::file::USER_FILE);
+    util::FileManager<Notification> notificationFileManager(config::file::NOTIFICATION_FILE);
+    auto& users = m_dataStore.getUsers();
+    util::Map<std::string, Notification*> notifications;
+    for (int userIndex = 0; userIndex < users.getSize(); userIndex++)
+    {
+        User* user = users.getValueAt(userIndex);
+        auto& userNotifications = user->getNotifications();
+        for (int notificationIndex = 0; notificationIndex < userNotifications.getSize(); notificationIndex++)
+        {
+            notifications[userNotifications.getKeyAt(notificationIndex)] =
+                userNotifications.getValueAt(notificationIndex);
+        }
+    }
+    userFileManager.save(users);
+    notificationFileManager.save(notifications);
 }
@@ -30,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();
 };