Add standardized documentation headers

<UserStory> INV004: Check Availability Status </UserStory>

<Changes>
    1. Updated Controller to delegate getInventoryItem calls to InventoryManagementService.
    2. Implemented InventoryManagementService::getInventoryItem to fetch items from datastore by ID.
    3. Enhanced AdminMenu with checkStockAvailability function:
       - Accepts part ID as input.
       - Retrieves item details from Controller.
       - Displays item information (ID, part name, quantity) if found and active.
       - Handles inactive or missing items gracefully.
</Changes>

<Test>

  Precondition:
  1. Admin user is logged into the system.
  2. Inventory contains multiple items with unique IDs.
  3. DataStore is initialized and accessible.

  Steps:
  1. Navigate to Admin Menu and select "Check Stock Availability".
    - Verify that the system prompts for an Item ID.
  2. Enter a valid Item ID for an active item.
    - Verify that the system displays the item’s details including current quantity.
  3. Enter an Item ID that does not exist.
    - Verify that the system displays “Item not found”.
  4. Enter an Item ID for an inactive item.
    - Verify that the system does not display details and indicates the item is inactive.
</Test>

<Review>
Sreeja Reghukumar
</Review>

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

@@ -171,16 +171,11 @@
     <ClInclude Include="services\PaymentManagementService.h" />
     <ClInclude Include="services\ServiceManagementService.h" />
     <ClInclude Include="services\UserManagementService.h" />
-    <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" />
-    <ClInclude Include="utilities\StringHelper.h" />
     <ClInclude Include="utilities\Timestamp.h" />
-    <ClInclude Include="utilities\Utility.h" />
     <ClInclude Include="utilities\Validator.h" />
     <ClInclude Include="utilities\Vector.h" />
     <ClInclude Include="views\AdminMenu.h" />

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

@@ -233,20 +233,5 @@
     <ClInclude Include="models\ComboPackage.h">
       <Filter>Header Files\Models</Filter>
     </ClInclude>
-    <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>
-    <ClInclude Include="utilities\FileHelper.h">
-      <Filter>Header Files\Utilities</Filter>
-    </ClInclude>
-    <ClInclude Include="utilities\Utility.h">
-      <Filter>Header Files\Utilities</Filter>
-    </ClInclude>
   </ItemGroup>
 </Project>

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

@@ -1,5 +1,20 @@
+/*
+File: Controller.cpp
+Description: Implementation file containing the method definitions
+             of the Controller class, which manages user authentication,
+             inventory, services, bookings, and notifications.
+Author: Trenser
+Date:19-May-2026
+*/
 #include "Controller.h"
 
+/*
+Function: login
+Description: Authenticates a user based on provided credentials.
+Parameter: const std::string& username - the username of the user
+           const std::string& password - the password of the user
+Return type: bool
+*/
 bool Controller::login(const std::string& username, const std::string& password)
 {
     return false;
@@ -48,22 +63,70 @@ void Controller::purchaseComboPackage(const std::string& comboPackageID, const s
 {
 }
 
+/*
+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()
 {
-    return util::Map<std::string, const InventoryItem*>();
+    auto inventoryIems = m_inventoryManagementService.getInventoryItems();
+    util::Map<std::string, const InventoryItem*> readOnlyInventoryItems;
+    int inventoryItemsMapSize = inventoryIems.getSize();
+    for (int index = 0; index < inventoryItemsMapSize; index++)
+    {
+        readOnlyInventoryItems.insert(inventoryIems.getKeyAt(index), inventoryIems.getValueAt(index));
+    }
+    return readOnlyInventoryItems;
 }
 
+/*
+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 nullptr;
+    return m_inventoryManagementService.getInventoryItem(inventoryItemID);
 }
 
+/*
+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: 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);
 }
 
 util::Map<std::string, const ServiceBooking*> Controller::getServiceBookings()
@@ -141,54 +204,6 @@ void Controller::configureNotifications(const std::string& userID, bool paymentN
 {
 }
 
-/*
-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::loadSystemData()
-{
-    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: 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();
-}
-
 void Controller::runSystemChecks()
 {
 }

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

@@ -1,11 +1,16 @@
+/*
+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.
+Author: Trenser
+Date:19-May-2026
+*/
 #pragma once
 #include "Map.h"
 #include <string>
 #include "Enums.h"
-#include "InventoryManagementService.h"
+#include "InventoryManagementService.h";
-#include "UserManagementService.h"
-#include "ServiceManagementService.h"
-#include "PaymentManagementService.h"
 
 class Service;
 class ComboPackage;
@@ -19,10 +24,7 @@ class Notification;
 class Controller
 {
 private:
-    UserManagementService m_userManagementService;
     InventoryManagementService m_inventoryManagementService;
-    ServiceManagementService m_serviceManagementService;
-    PaymentManagementService m_paymentManagementService;
 public:
     bool login(const std::string& username, const std::string& password);
     void logout();
@@ -56,7 +58,6 @@ public:
     util::Vector<const Notification*> getNotifications();
     void deleteNotification(const std::string& notificationID);
     void configureNotifications(const std::string& userID, bool paymentNotifications, bool serviceNotifications);
-    void loadSystemData();
+    void addInventoryItemStock(const std::string& selectedItemId, int quantity);
-    void saveSystemData();
     void runSystemChecks();
 };

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/core/patterns/Subject.h

@@ -1,7 +1,6 @@
 #pragma once
 #include <string>
 #include "Map.h"
-#include "Vector.h"
 
 class User;
 class Notification;

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

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

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

@@ -1,9 +1,4 @@
-#include <sstream>
-#include <stdexcept>
 #include "ComboPackage.h"
-#include "Service.h"
-#include "Factory.h"
-#include "StringHelper.h"
 
 int ComboPackage::m_uid = 0;
 
@@ -17,42 +12,7 @@ ComboPackage::ComboPackage(const std::string& packageName, double discountPercen
     m_packageName(packageName),
     m_discountPercentage(discountPercentage),
     m_status(util::State::ACTIVE),
-    m_services(services)
+    m_services(services) {}
-{
-    int numberOfServices = m_services.getSize();
-    auto servicePointers = m_services.getValues();
-    for (int index = 0; index < numberOfServices; index++)
-    {
-        m_serviceIDs.push_back(servicePointers[index]->getId());
-    }
-}
-
-/*
-Function: ComboPackage (parameterized constructor with ID)
-Description: Initializes a combo package with an existing ID, name, discount percentage,
-             service IDs, and state. Updates UID tracking based on ID.
-Parameters:
-    - id: const std::string&, unique ID of the package
-    - packageName: const std::string&, name of the package
-    - discountPercentage: double, discount percentage applied
-    - serviceIDs: const util::Vector<std::string>&, IDs of services included
-    - status: util::State, state of the package (ACTIVE/INACTIVE)
-Returns:
-    - A new ComboPackage object
-*/
-ComboPackage::ComboPackage(const std::string& id, const std::string& packageName, double discountPercentage, const util::Vector<std::string>& serviceIDs, util::State status)
-    : m_id(id),
-    m_packageName(packageName),
-    m_discountPercentage(discountPercentage),
-    m_serviceIDs(serviceIDs),
-    m_status(status)
-{
-    int idNumber = util::extractNumber(m_id);
-    if (idNumber > m_uid)
-    {
-        m_uid = idNumber;
-    }
-}
 
 const std::string& ComboPackage::getId() const
 {
@@ -74,11 +34,6 @@ util::State ComboPackage::getState() const
     return m_status;
 }
 
-const util::Vector<std::string>& ComboPackage::getServiceIDs() const
-{
-    return m_serviceIDs;
-}
-
 const util::Map<std::string, Service*>& ComboPackage::getServices() const
 {
     return m_services;
@@ -102,131 +57,9 @@ void ComboPackage::setDiscountPercentage(double discountPercentage)
 void ComboPackage::setServices(const util::Map<std::string, Service*>& services)
 {
     m_services = services;
-    m_serviceIDs.clear();
-    int numberOfServices = m_services.getSize();
-    auto servicePointers = m_services.getValues();
-    for (int index = 0; index < numberOfServices; index++)
-    {
-        m_serviceIDs.push_back(servicePointers[index]->getId());
-    }
 }
 
 void ComboPackage::setState(util::State status)
 {
     m_status = status;
 }
-
-/*
-Function: getServiceIDsAsString (static helper)
-Description: Converts a vector of service IDs into a single string separated by '|'.
-Parameters:
-    - serviceIDs: const util::Vector<std::string>&, vector of service IDs
-Returns:
-    - std::string: Concatenated service IDs string
-*/
-static std::string getServiceIDsAsString(const util::Vector<std::string>& serviceIDs)
-{
-    int numberOfServices = serviceIDs.getSize();
-    std::string serviceIDsString;
-    for (int index = 0; index < numberOfServices; index++)
-    {
-        serviceIDsString += serviceIDs[index];
-        if (index < numberOfServices - 1)
-        {
-            serviceIDsString += '|';
-        }
-    }
-    return serviceIDsString;
-}
-
-/*
-Function: getServiceIDsAsVector (static helper)
-Description: Converts a string of service IDs separated by '|' into a vector.
-Parameters:
-    - serviceIDsString: const std::string&, concatenated service IDs string
-Returns:
-    - util::Vector<std::string>: Vector of service IDs
-*/
-static util::Vector<std::string> getServiceIDsAsVector(const std::string& serviceIDsString)
-{
-    util::Vector<std::string> serviceIDs;
-    std::string serviceID;
-    std::istringstream serializedServiceIDs(serviceIDsString);
-    while (getline(serializedServiceIDs, serviceID, '|'))
-    {
-        serviceIDs.push_back(serviceID);
-    }
-    return serviceIDs;
-}
-
-/*
-Function: serialize
-Description: Serializes the combo package into a CSV-formatted string.
-Parameters:
-    - None
-Returns:
-    - std::string: Serialized combo package record
-*/
-std::string ComboPackage::serialize() const
-{
-    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 CSV-formatted string into a ComboPackage object.
-Parameters:
-    - 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 std::string& record)
-{
-    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>(
-        id,
-        packageName,
-        discountPercentage,
-        serviceIDs,
-        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

@@ -1,7 +1,6 @@
 #pragma once
 #include <string>
 #include "Map.h"
-#include "Vector.h"
 #include "Enums.h"
 
 class Service;
@@ -13,17 +12,14 @@ private:
     std::string m_id;
     std::string m_packageName;
     double m_discountPercentage;
-    util::Vector<std::string> m_serviceIDs;
     util::Map<std::string, Service*> m_services;
     util::State m_status;
 public:
     ComboPackage();
     ComboPackage(const std::string& packageName, double discountPercentage, const util::Map<std::string, Service*>& services);
-    ComboPackage(const std::string& id, const std::string& packageName, double discountPercentage, const util::Vector<std::string>& serviceIDs, util::State status);
     const std::string& getId() const;
     const std::string& getPackageName() const;
     double getDiscountPercentage() const;
-    const util::Vector<std::string>& getServiceIDs() const;
     const util::Map<std::string, Service*>& getServices() const;
     util::State getState() const;
     void setId(const std::string& id);
@@ -31,7 +27,4 @@ public:
     void setDiscountPercentage(double discountPercentage);
     void setServices(const util::Map<std::string, Service*>& services);
     void setState(util::State status);
-    std::string serialize() const;
-    static ComboPackage* deserialize(const std::string&);
-    static std::string getHeaders();
 };

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

@@ -1,7 +1,3 @@
-#include <sstream>
-#include <stdexcept>
-#include "Factory.h"
-#include "StringHelper.h"
 #include "InventoryItem.h"
 
 int InventoryItem::m_uid = 0;
@@ -19,33 +15,6 @@ InventoryItem::InventoryItem(const std::string& partName, int quantity, double p
     m_status(util::State::ACTIVE),
     m_price(price) {}
 
-/*
-Function: InventoryItem (parameterized constructor with ID)
-Description: Initializes an inventory item with an existing ID, part name, quantity,
-             price, and state. Updates UID tracking based on ID.
-Parameters:
-    - id: const std::string&, unique ID of the item
-    - partName: const std::string&, name of the part
-    - quantity: int, quantity of the part
-    - price: double, price of the part
-    - status: util::State, state of the item (ACTIVE/INACTIVE)
-Returns:
-    - A new InventoryItem object
-*/
-InventoryItem::InventoryItem(const std::string& id, const std::string& partName, int quantity, double price, util::State status)
-    : m_id(id),
-    m_partName(partName),
-    m_quantity(quantity),
-    m_status(status),
-    m_price(price)
-{
-    int idNumber = util::extractNumber(m_id);
-    if (idNumber > m_uid)
-    {
-        m_uid = idNumber;
-    }
-}
-
 const std::string& InventoryItem::getId() const
 {
     return m_id;
@@ -95,76 +64,3 @@ void InventoryItem::setState(util::State status)
 {
     m_status = status;
 }
-
-/*
-Function: serialize
-Description: Serializes the inventory item into a CSV-formatted string.
-Parameters:
-    - None
-Returns:
-    - std::string: Serialized inventory item record
-*/
-std::string InventoryItem::serialize() const
-{
-    std::ostringstream serializedInventoryItem;
-    serializedInventoryItem << m_id << ','
-        << m_partName << ','
-        << m_quantity << ','
-        << m_price << ','
-        << util::getStateString(m_status);
-    return serializedInventoryItem.str();
-}
-
-/*
-Function: deserialize
-Description: Deserializes a CSV-formatted string into an InventoryItem object.
-Parameters:
-    - 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 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>(
-        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

@@ -14,7 +14,6 @@ private:
 public:
     InventoryItem();
     InventoryItem(const std::string& partName, int quantity, double price);
-    InventoryItem(const std::string& id, const std::string& partName, int quantity, double price, util::State status);
     const std::string& getId() const;
     const std::string& getPartName() const;
     int getQuantity() const;
@@ -25,7 +24,4 @@ public:
     void setQuantity(int quantity);
     void setPrice(double price);
     void setState(util::State status);
-    std::string serialize() const;
-    static InventoryItem* deserialize(const std::string&);
-    static std::string getHeaders();
 };

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

@@ -1,9 +1,4 @@
-#include <sstream>
-#include <stdexcept>
 #include "Invoice.h"
-#include "Factory.h"
-#include "InventoryItem.h"
-#include "StringHelper.h"
 
 int Invoice::m_uid = 0;
 
@@ -21,7 +16,7 @@ Invoice::Invoice(
     const std::string& bookingId,
     ServiceBooking* booking,
     const util::Timestamp& invoiceDate, 
-    double laborCost, const util::Map<std::string,
+    double laborCost, const util::Map<int,
     InventoryItem*>& parts,
     double partsCost,
     double discountPercentage, 
@@ -41,48 +36,7 @@ Invoice::Invoice(
     m_totalAmount(totalAmount),
     m_paymentDate(paymentDate),
     m_paymentMethod(paymentMethod),
-    m_status(status) 
+    m_status(status) {}
-{
-    int numberOfParts = m_parts.getSize();
-    auto partPointers = m_parts.getValues();
-    for (int index = 0; index < numberOfParts; index++)
-    {
-        m_partIDs.push_back(partPointers[index]->getId());
-    }
-}
-
-Invoice::Invoice(
-    const std::string& id,
-    const std::string& bookingId,
-    const util::Timestamp& invoiceDate,
-    const util::Vector<std::string>& partIDs,
-    double laborCost,
-    double partsCost,
-    double discountPercentage,
-    double totalAmount,
-    const util::Timestamp& paymentDate,
-    util::PaymentMode paymentMethod,
-    util::PaymentStatus status
-)
-    : m_id(id),
-    m_bookingId(bookingId),
-    m_booking(nullptr),
-    m_invoiceDate(invoiceDate),
-    m_partIDs(partIDs),
-    m_laborCost(laborCost),
-    m_partsCost(partsCost),
-    m_discountPercentage(discountPercentage),
-    m_totalAmount(totalAmount),
-    m_paymentDate(paymentDate),
-    m_paymentMethod(paymentMethod),
-    m_status(status)
-{
-    int idNumber = util::extractNumber(m_id);
-    if (idNumber > m_uid)
-    {
-        m_uid = idNumber;
-    }
-}
 
 const std::string& Invoice::getId() const
 {
@@ -109,20 +63,7 @@ double Invoice::getLaborCost() const
     return m_laborCost;
 }
 
-/*
+const util::Map<int, InventoryItem*>& Invoice::getParts() const
-Function: getPartIDs
-Description: Retrieves the IDs of parts used in the invoice.
-Parameters:
-    - None
-Returns:
-    - const util::Vector<std::string>&: Part IDs
-*/
-const util::Vector<std::string>& Invoice::getPartIDs() const
-{
-    return m_partIDs;
-}
-
-const util::Map<std::string, InventoryItem*>& Invoice::getParts() const
 {
     return m_parts;
 }
@@ -182,16 +123,9 @@ void Invoice::setLaborCost(double laborCost)
     m_laborCost = laborCost;
 }
 
-void Invoice::setParts(const util::Map<std::string, InventoryItem*>& parts)
+void Invoice::setParts(const util::Map<int, InventoryItem*>& parts)
 {
     m_parts = parts;
-    m_partIDs.clear();
-    int numberOfParts = m_parts.getSize();
-    auto partPointers = m_parts.getValues();
-    for (int index = 0; index < numberOfParts; index++)
-    {
-        m_partIDs.push_back(partPointers[index]->getId());
-    }
 }
 
 void Invoice::setPartsCost(double partsCost)
@@ -223,146 +157,3 @@ void Invoice::setStatus(util::PaymentStatus status)
 {
     m_status = status;
 }
-
-/*
-Function: getPartIDsAsString (static helper)
-Description: Converts a vector of part IDs into a single string separated by '|'.
-Parameters:
-    - partIDs: const util::Vector<std::string>&, vector of part IDs
-Returns:
-    - std::string: Concatenated part IDs string
-*/
-static std::string getPartIDsAsString(const util::Vector<std::string>& partIDs)
-{
-    int numberOfParts = partIDs.getSize();
-    std::string partIDsString;
-    for (int index = 0; index < numberOfParts; index++)
-    {
-        partIDsString += partIDs[index];
-        if (index < numberOfParts - 1)
-        {
-            partIDsString += '|';
-        }
-    }
-    return partIDsString;
-}
-
-/*
-Function: getPartIDsAsVector (static helper)
-Description: Converts a string of part IDs separated by '|' into a vector.
-Parameters:
-    - partIDsString: const std::string&, concatenated part IDs string
-Returns:
-    - util::Vector<std::string>: Vector of part IDs
-*/
-static util::Vector<std::string> getPartIDsAsVector(const std::string& partIDsString)
-{
-    util::Vector<std::string> partIDs;
-    std::string partID;
-    std::istringstream serializedPartIDs(partIDsString);
-    while (getline(serializedPartIDs, partID, '|'))
-    {
-        partIDs.push_back(partID);
-    }
-    return partIDs;
-}
-
-/*
-Function: serialize
-Description: Serializes the invoice into a CSV-formatted string.
-Parameters:
-    - None
-Returns:
-    - std::string: Serialized invoice record
-*/
-std::string Invoice::serialize() const
-{
-    std::ostringstream serializedInvoice;
-    serializedInvoice << m_id << ','
-        << m_bookingId << ','
-        << m_invoiceDate.toString() << ','
-        << m_laborCost << ','
-        << getPartIDsAsString(m_partIDs) << ','
-        << m_partsCost << ','
-        << m_discountPercentage << ','
-        << m_totalAmount << ','
-        << m_paymentDate.toString() << ','
-        << util::getPaymentModeString(m_paymentMethod) << ','
-        << util::getPaymentStatusString(m_status);
-    return serializedInvoice.str();
-}
-
-/*
-Function: deserialize
-Description: Deserializes a CSV-formatted string into an Invoice object.
-Parameters:
-    - 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 std::string& record)
-{
-    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>(
-        id,
-        bookingId,
-        invoiceDate,
-        partIDs,
-        laborCost,
-        partsCost,
-        discountPercentage,
-        totalAmount,
-        paymentDate,
-        paymentMethod,
-        status
-    );
-}
-
-/*
-Function: getHeaders
-Description: Retrieves the CSV headers for invoice serialization.
-Parameters:
-    - None
-Returns:
-    - std::string: Header string ("ID,BookingID,InvoiceDate,LaborCost,PartIDs,PartsCost,DiscountPercentage,TotalAmount,PaymentDate,PaymentMethod,Status")
-*/
-std::string Invoice::getHeaders()
-{
-    return "ID,BookingID,InvoiceDate,LaborCost,PartIDs,PartsCost,DiscountPercentage,TotalAmount,PaymentDate,PaymentMethod,Status";
-}

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

@@ -1,7 +1,6 @@
 #pragma once
 #include <string>
 #include "Map.h"
-#include "Vector.h"
 #include "Timestamp.h"
 #include "Enums.h"
 
@@ -17,21 +16,21 @@ private:
     ServiceBooking* m_booking;
     util::Timestamp m_invoiceDate;
     double m_laborCost;
-    util::Vector<std::string> m_partIDs;
+    util::Map<int, InventoryItem*> m_parts;
-    util::Map<std::string, InventoryItem*> m_parts;
     double m_partsCost;
     double m_discountPercentage;
     double m_totalAmount;
     util::Timestamp m_paymentDate;
     util::PaymentMode m_paymentMethod;
     util::PaymentStatus m_status;
+
 public:
     Invoice();
     Invoice(
         const std::string& bookingId,
         ServiceBooking* booking,
         const util::Timestamp& invoiceDate, 
-        double laborCost, const util::Map<std::string,
+        double laborCost, const util::Map<int,
         InventoryItem*>& parts,
         double partsCost,
         double discountPercentage, 
@@ -40,26 +39,12 @@ public:
         util::PaymentMode paymentMethod, 
         util::PaymentStatus status
     );
-    Invoice(
-        const std::string& id,
-        const std::string& bookingId,
-        const util::Timestamp& invoiceDate,
-        const util::Vector<std::string>& partIDs,
-        double laborCost,
-        double partsCost,
-        double discountPercentage,
-        double totalAmount,
-        const util::Timestamp& paymentDate,
-        util::PaymentMode paymentMethod,
-        util::PaymentStatus status
-    );
     const std::string& getId() const;
     const std::string& getBookingId() const;
     ServiceBooking* getBooking() const;
     const util::Timestamp& getInvoiceDate() const;
     double getLaborCost() const;
-    const util::Vector<std::string>& getPartIDs() const;
+    const util::Map<int, InventoryItem*>& getParts() const;
-    const util::Map<std::string, InventoryItem*>& getParts() const;
     double getPartsCost() const;
     double getDiscountPercentage() const;
     double getTotalAmount() const;
@@ -71,14 +56,11 @@ public:
     void setBooking(ServiceBooking* booking);
     void setInvoiceDate(const util::Timestamp& invoiceDate);
     void setLaborCost(double laborCost);
-    void setParts(const util::Map<std::string, InventoryItem*>& parts);
+    void setParts(const util::Map<int, InventoryItem*>& parts);
     void setPartsCost(double partsCost);
     void setDiscountPercentage(double discountPercentage);
     void setTotalAmount(double totalAmount);
     void setPaymentDate(const util::Timestamp& paymentDate);
     void setPaymentMethod(util::PaymentMode paymentMethod);
     void setStatus(util::PaymentStatus status);
-    std::string serialize() const;
-    static Invoice* deserialize(const std::string&);
-    static std::string getHeaders();
 };

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

@@ -1,9 +1,4 @@
-#include <sstream>
-#include <stdexcept>
 #include "JobCard.h"
-#include "Factory.h"
-#include "StringHelper.h"
-#include "Enums.h"
 
 int JobCard::m_uid = 0;
 
@@ -12,7 +7,7 @@ JobCard::JobCard()
     m_booking(nullptr),
     m_service(nullptr),
     m_technician(nullptr),
-    m_status(util::ServiceJobStatus()) {}
+    m_status(ServiceJobStatus()) {}
 
 JobCard::JobCard(const std::string& bookingId,
     ServiceBooking* booking,
@@ -21,7 +16,7 @@ JobCard::JobCard(const std::string& bookingId,
     const std::string& technicianId,
     User* technician,
     const util::Timestamp& assignedDate,
-    util::ServiceJobStatus status,
+    ServiceJobStatus status,
     const util::Timestamp& completionDate
 )
     : m_id("JC" + std::to_string(++m_uid)),
@@ -35,48 +30,6 @@ JobCard::JobCard(const std::string& bookingId,
     m_status(status),
     m_completionDate(completionDate) {}
 
-/*
-Function: JobCard (parameterized constructor with ID)
-Description: Initializes a job card with an existing ID, booking ID, service ID,
-             technician ID, assignment date, completion date, and status.
-             Updates UID tracking based on ID.
-Parameters:
-    - id: const std::string&, unique job card ID
-    - bookingId: const std::string&, ID of the booking
-    - serviceId: const std::string&, ID of the service
-    - technicianId: const std::string&, ID of the technician
-    - assignedDate: const util::Timestamp&, date of assignment
-    - status: util::ServiceJobStatus, job status
-    - completionDate: const util::Timestamp&, date of completion
-Returns:
-    - A new JobCard object
-*/
-JobCard::JobCard(const std::string& id,
-    const std::string& bookingId,
-    const std::string& serviceId,
-    const std::string& technicianId,
-    const util::Timestamp& assignedDate,
-    util::ServiceJobStatus status,
-    const util::Timestamp& completionDate
-)
-    : m_id(id),
-    m_bookingId(bookingId),
-    m_booking(nullptr),
-    m_service(nullptr),
-    m_serviceId(serviceId),
-    m_technicianId(technicianId),
-    m_technician(nullptr),
-    m_assignedDate(assignedDate),
-    m_status(status),
-    m_completionDate(completionDate)
-{
-    int idNumber = util::extractNumber(m_id);
-    if (idNumber > m_uid)
-    {
-        m_uid = idNumber;
-    }
-}
-
 const std::string& JobCard::getId() const
 {
     return m_id;
@@ -117,7 +70,7 @@ const util::Timestamp& JobCard::getAssignedDate() const
     return m_assignedDate;
 }
 
-util::ServiceJobStatus JobCard::getStatus() const
+ServiceJobStatus JobCard::getStatus() const
 {
     return m_status;
 }
@@ -167,7 +120,7 @@ void JobCard::setAssignedDate(const util::Timestamp& assignedDate)
     m_assignedDate = assignedDate;
 }
 
-void JobCard::setStatus(util::ServiceJobStatus status)
+void JobCard::setStatus(ServiceJobStatus status)
 {
     m_status = status;
 }
@@ -176,82 +129,3 @@ void JobCard::setCompletionDate(const util::Timestamp& completionDate)
 {
     m_completionDate = completionDate;
 }
-
-/*
-Function: serialize
-Description: Serializes the job card into a CSV-formatted string.
-Parameters:
-    - None
-Returns:
-    - std::string: Serialized job card record
-*/
-std::string JobCard::serialize() const
-{
-    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 CSV-formatted string into a JobCard object.
-Parameters:
-    - 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 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>(
-        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,12 +1,13 @@
 #pragma once
 #include <string>
 #include "Timestamp.h"
-#include "Enums.h"
 
 class ServiceBooking;
 class Service;
 class User;
 
+enum class ServiceJobStatus : int;
+
 class JobCard
 {
 private:
@@ -19,7 +20,7 @@ private:
     std::string m_technicianId;
     User* m_technician;
     util::Timestamp m_assignedDate;
-    util::ServiceJobStatus m_status;
+    ServiceJobStatus m_status;
     util::Timestamp m_completionDate;
 
 public:
@@ -31,15 +32,7 @@ public:
         const std::string& technicianId, 
         User* technician, 
         const util::Timestamp& assignedDate, 
-        util::ServiceJobStatus status,
+        ServiceJobStatus status,
-        const util::Timestamp& completionDate
-    );
-    JobCard(const std::string& id,
-        const std::string& bookingId,
-        const std::string& serviceId,
-        const std::string& technicianId,
-        const util::Timestamp& assignedDate,
-        util::ServiceJobStatus status,
         const util::Timestamp& completionDate
     );
     const std::string& getId() const;
@@ -50,7 +43,7 @@ public:
     const std::string& getTechnicianId() const;
     User* getTechnician() const;
     const util::Timestamp& getAssignedDate() const;
-    util::ServiceJobStatus getStatus() const;
+    ServiceJobStatus getStatus() const;
     const util::Timestamp& getCompletionDate() const;
     void setId(const std::string& id);
     void setBookingId(const std::string& bookingId);
@@ -60,9 +53,6 @@ public:
     void setTechnicianId(const std::string& technicianId);
     void setTechnician(User* technician);
     void setAssignedDate(const util::Timestamp& assignedDate);
-    void setStatus(util::ServiceJobStatus status);
+    void setStatus(ServiceJobStatus status);
     void setCompletionDate(const util::Timestamp& completionDate);
-    std::string serialize() const;
-    static JobCard* deserialize(const std::string&);
-    static std::string getHeaders();
 };

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

@@ -1,7 +1,4 @@
-#include <sstream>
 #include "Notification.h"
-#include "StringHelper.h"
-#include "Factory.h"
 
 int Notification::m_uid = 0;
 
@@ -17,34 +14,6 @@ Notification::Notification(const std::string& recipientUserId, User* recipient,
     m_message(message),
     m_createdAt(createdAt) {}
 
-/*
-Function: Notification (parameterized constructor with ID)
-Description: Initializes a notification with an existing ID, recipient details,
-             title, message, and creation timestamp. Updates UID tracking based on ID.
-Parameters:
-    - id: const std::string&, unique notification ID
-    - recipientUserId: const std::string&, ID of the recipient user
-    - title: const std::string&, notification title
-    - message: const std::string&, notification message
-    - createdAt: const util::Timestamp&, timestamp of creation
-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)
-    : m_id(id),
-    m_recipientUserId(recipientUserId),
-    m_recipient(nullptr),
-    m_title(title),
-    m_message(message),
-    m_createdAt(createdAt) 
-{
-    int idNumber = util::extractNumber(m_id);
-    if (idNumber > m_uid)
-    {
-        m_uid = idNumber;
-    }
-}
-
 const std::string& Notification::getId() const 
 {
     return m_id;
@@ -104,72 +73,3 @@ void Notification::setCreatedAt(const util::Timestamp& createdAt)
 {
     m_createdAt = createdAt;
 }
-
-/*
-Function: serialize
-Description: Serializes the notification into a CSV-formatted string.
-Parameters:
-    - None
-Returns:
-    - std::string: Serialized notification record
-*/
-std::string Notification::serialize() const
-{
-    std::ostringstream serializedNotification;
-    serializedNotification << m_id << ','
-        << m_recipientUserId << ','
-        << m_title << ','
-        << m_message << ','
-        << m_createdAt.toString();
-    return serializedNotification.str();
-}
-
-/*
-Function: deserialize
-Description: Deserializes a CSV-formatted string into a Notification object.
-Parameters:
-    - 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 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>(
-        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

@@ -17,7 +17,6 @@ private:
 public:
     Notification();
     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;
@@ -30,7 +29,4 @@ public:
     void setTitle(const std::string& title);
     void setMessage(const std::string& message);
     void setCreatedAt(const util::Timestamp& createdAt);
-    std::string serialize() const;
-    static Notification* deserialize(const std::string&);
-    static std::string getHeaders();
 };

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

@@ -1,8 +1,4 @@
-#include <sstream>
 #include "Service.h"
-#include "InventoryItem.h"
-#include "StringHelper.h"
-#include "Factory.h"
 
 int Service::m_uid = 0;
 
@@ -16,42 +12,7 @@ Service::Service(const std::string& name, const util::Map<std::string, Inventory
     m_name(name),
     m_requiredInventoryItems(requiredInventoryItems),
     m_status(util::State::ACTIVE),
-    m_laborCost(laborCost) 
+    m_laborCost(laborCost) {}
-{
-    int numberOfInventoryItems = m_requiredInventoryItems.getSize();
-    auto inventoryItemPointers = m_requiredInventoryItems.getValues();
-    for (int index = 0; index < numberOfInventoryItems; index++)
-    {
-        m_requiredInventoryItemIDs.push_back(inventoryItemPointers[index]->getId());
-    }
-}
-
-/*
-Function: Service (parameterized constructor with ID)
-Description: Initializes a service with an existing ID, name, inventory item IDs,
-             labor cost, and state. Updates UID tracking based on ID.
-Parameters:
-    - id: const std::string&, unique service ID
-    - name: const std::string&, name of the service
-    - requiredInventoryItemIDs: const util::Vector<std::string>&, IDs of required inventory items
-    - laborCost: double, labor cost of the service
-    - status: util::State, state of the service (ACTIVE/INACTIVE)
-Returns:
-    - A new Service object
-*/
-Service::Service(const std::string& id, const std::string& name, const util::Vector<std::string>& requiredInventoryItemIDs, double laborCost, util::State status)
-    : m_id(id),
-    m_name(name),
-    m_requiredInventoryItemIDs(requiredInventoryItemIDs),
-    m_status(status),
-    m_laborCost(laborCost)
-{
-    int idNumber = util::extractNumber(m_id);
-    if (idNumber > m_uid)
-    {
-        m_uid = idNumber;
-    }
-}
 
 const std::string& Service::getId() const
 {
@@ -63,19 +24,6 @@ const std::string& Service::getName() const
     return m_name;
 }
 
-/*
-Function: getRequiredInventoryItemIDs
-Description: Retrieves the IDs of required inventory items for the service.
-Parameters:
-    - None
-Returns:
-    - const util::Vector<std::string>&: Inventory item IDs
-*/
-const util::Vector<std::string>& Service::getRequiredInventoryItemIDs() const
-{
-    return m_requiredInventoryItemIDs;
-}
-
 const util::Map<std::string, InventoryItem*>& Service::getRequiredInventoryItems() const
 {
     return m_requiredInventoryItems;
@@ -104,13 +52,6 @@ void Service::setName(const std::string& name)
 void Service::setRequiredInventoryItems(const util::Map<std::string, InventoryItem*>& requiredInventoryItems)
 {
     m_requiredInventoryItems = requiredInventoryItems;
-    m_requiredInventoryItemIDs.clear();
-    int numberOfRequiredInventoryItems = m_requiredInventoryItems.getSize();
-    auto inventoryItemPointers = m_requiredInventoryItems.getValues();
-    for (int index = 0; index < numberOfRequiredInventoryItems; index++)
-    {
-        m_requiredInventoryItemIDs.push_back(inventoryItemPointers[index]->getId());
-    }
 }
 
 void Service::setLaborCost(double laborCost)
@@ -122,118 +63,3 @@ void Service::setState(util::State status)
 {
     m_status = status;
 }
-
-/*
-Function: getInventoryItemIDsAsString (static helper)
-Description: Converts a vector of inventory item IDs into a single string separated by '|'.
-Parameters:
-    - inventoryItemIds: const util::Vector<std::string>&, vector of inventory item IDs
-Returns:
-    - std::string: Concatenated inventory item IDs string
-*/
-static std::string getInventoryItemIDsAsString(const util::Vector<std::string>& inventoryItemIds)
-{
-    int numberOfInventoryItems = inventoryItemIds.getSize();
-    std::string inventoryItemIDs;
-    for (int index = 0; index < numberOfInventoryItems; index++)
-    {
-        inventoryItemIDs += inventoryItemIds[index];
-        if (index < numberOfInventoryItems - 1)
-        {
-            inventoryItemIDs += '|';
-        }
-    }
-    return inventoryItemIDs;
-}
-
-/*
-Function: getInventoryItemIDsAsVector (static helper)
-Description: Converts a string of inventory item IDs separated by '|' into a vector.
-Parameters:
-    - inventoryItemIDsString: const std::string&, concatenated inventory item IDs string
-Returns:
-    - util::Vector<std::string>: Vector of inventory item IDs
-*/
-static util::Vector<std::string> getInventoryItemIDsAsVector(const std::string& inventoryItemIDsString)
-{
-    util::Vector<std::string> inventoryItemIDs;
-    std::string inventoryItemID;
-    std::istringstream serializedInventoryItemIDs(inventoryItemIDsString);
-    while (getline(serializedInventoryItemIDs, inventoryItemID, '|'))
-    {
-        inventoryItemIDs.push_back(inventoryItemID);
-    }
-    return inventoryItemIDs;
-}
-
-/*
-Function: serialize
-Description: Serializes the service into a CSV-formatted string.
-Parameters:
-    - None
-Returns:
-    - std::string: Serialized service record
-*/
-std::string Service::serialize() const
-{
-    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 CSV-formatted string into a Service object.
-Parameters:
-    - 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 std::string& record)
-{
-    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>(
-        id,
-        name,
-        inventoryItemIDs,
-        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

@@ -1,7 +1,6 @@
 #pragma once
 #include <string>
 #include "Map.h"
-#include "Vector.h"
 #include "Enums.h"
 
 class InventoryItem;
@@ -12,17 +11,14 @@ private:
     static int m_uid;
     std::string m_id;
     std::string m_name;
-    util::Vector<std::string> m_requiredInventoryItemIDs;
     util::Map<std::string, InventoryItem*> m_requiredInventoryItems;
     double m_laborCost;
     util::State m_status;
 public:
     Service();
     Service(const std::string& name, const util::Map<std::string, InventoryItem*>& requiredInventoryItems, double laborCost);
-    Service(const std::string& id, const std::string& name, const util::Vector<std::string>& requiredInventoryItemIDs, double laborCost, util::State state);
     const std::string& getId() const;
     const std::string& getName() const;
-    const util::Vector<std::string>& getRequiredInventoryItemIDs() const;
     const util::Map<std::string, InventoryItem*>& getRequiredInventoryItems() const;
     double getLaborCost() const;
     util::State getState() const;
@@ -31,7 +27,4 @@ public:
     void setRequiredInventoryItems(const util::Map<std::string, InventoryItem*>& requiredInventoryItems);
     void setLaborCost(double laborCost);
     void setState(util::State status);
-    std::string serialize() const;
-    static Service* deserialize(const std::string&);
-    static std::string getHeaders();
 };

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

@@ -1,20 +1,14 @@
-#include <stdexcept>
-#include <sstream>
 #include "ServiceBooking.h"
-#include "Service.h"
-#include "Enums.h"
-#include "Factory.h"
-#include "StringHelper.h"
 
 int ServiceBooking::m_uid = 0;
 
 ServiceBooking::ServiceBooking()
     : m_id("SRV" + std::to_string(++m_uid)),
     m_customer(nullptr),
-    m_assignedTechnician(nullptr),
     m_discountPercentage(0.0) {}
 
 ServiceBooking::ServiceBooking(
+    const std::string& id,
     util::ServiceJobStatus status,
     const util::Map<std::string,
     Service*>& services,
@@ -24,7 +18,7 @@ ServiceBooking::ServiceBooking(
     const std::string& vehicleBrand,
     const std::string& vehicleModel,
     const std::string& assignedTechnicianId,
-    User* assignedTechnician,
+    const std::string& assignedTechnician,
     double discountPercentage
 )
     : m_id("SRV" + std::to_string(++m_uid)),
@@ -39,60 +33,6 @@ ServiceBooking::ServiceBooking(
     m_assignedTechnician(assignedTechnician),
     m_discountPercentage(discountPercentage)
 {
-    int numberOfServices = m_services.getSize();
-    auto servicePointers = m_services.getValues();
-    for (int index = 0; index < numberOfServices; index++)
-    {
-        m_serviceIDs.push_back(servicePointers[index]->getId());
-    }
-}
-
-/*
-Function: ServiceBooking (parameterized constructor with ID)
-Description: Initializes a service booking with an existing ID, status, service IDs,
-             customer details, vehicle details, technician ID, and discount percentage.
-             Updates UID tracking based on ID.
-Parameters:
-    - id: const std::string&, unique booking ID
-    - status: util::ServiceJobStatus, job status of the booking
-    - serviceIDs: const util::Vector<std::string>&, IDs of booked services
-    - customerId: const std::string&, ID of the customer
-    - vehicleNumber: const std::string&, vehicle number
-    - vehicleBrand: const std::string&, vehicle brand
-    - vehicleModel: const std::string&, vehicle model
-    - assignedTechnicianId: const std::string&, ID of the assigned technician
-    - discountPercentage: double, discount applied
-Returns:
-    - A new ServiceBooking object
-*/
-ServiceBooking::ServiceBooking(
-    const std::string& id,
-    util::ServiceJobStatus status,
-    const util::Vector<std::string>& serviceIDs,
-    const std::string& customerId,
-    const std::string& vehicleNumber,
-    const std::string& vehicleBrand,
-    const std::string& vehicleModel,
-    const std::string& assignedTechnicianId,
-    double discountPercentage
-)
-    : m_id(id),
-    m_status(status),
-    m_serviceIDs(serviceIDs),
-    m_customerId(customerId),
-    m_customer(nullptr),
-    m_vehicleNumber(vehicleNumber),
-    m_vehicleBrand(vehicleBrand),
-    m_vehicleModel(vehicleModel),
-    m_assignedTechnicianId(assignedTechnicianId),
-    m_assignedTechnician(nullptr),
-    m_discountPercentage(discountPercentage)
-{
-    int idNumber = util::extractNumber(m_id);
-    if (idNumber > m_uid)
-    {
-        m_uid = idNumber;
-    }
 }
 
 const std::string& ServiceBooking::getId() const
@@ -105,19 +45,6 @@ util::ServiceJobStatus ServiceBooking::getStatus() const
     return m_status;
 }
 
-/*
-Function: getServiceIDs
-Description: Retrieves the IDs of services booked.
-Parameters:
-    - None
-Returns:
-    - const util::Vector<std::string>&: Service IDs
-*/
-const util::Vector<std::string>& ServiceBooking::getServiceIDs() const
-{
-    return m_serviceIDs;
-}
-
 const util::Map<std::string, Service*>& ServiceBooking::getServices() const
 {
     return m_services;
@@ -153,7 +80,7 @@ const std::string& ServiceBooking::getAssignedTechnicianId() const
     return m_assignedTechnicianId;
 }
 
-const User* ServiceBooking::getAssignedTechnician() const
+const std::string& ServiceBooking::getAssignedTechnician() const
 {
     return m_assignedTechnician;
 }
@@ -176,13 +103,6 @@ void ServiceBooking::setStatus(const util::ServiceJobStatus& status)
 void ServiceBooking::setServices(const util::Map<std::string, Service*>& services)
 {
     m_services = services;
-    m_serviceIDs.clear();
-    int numberOfServices = m_services.getSize();
-    auto servicePointers = m_services.getValues();
-    for (int index = 0; index < numberOfServices; index++)
-    {
-        m_serviceIDs.push_back(servicePointers[index]->getId());
-    }
 }
 
 void ServiceBooking::setCustomerId(const std::string& customerId)
@@ -215,7 +135,7 @@ void ServiceBooking::setAssignedTechnicianId(const std::string& assignedTechnici
     m_assignedTechnicianId = assignedTechnicianId;
 }
 
-void ServiceBooking::setAssignedTechnician(User* assignedTechnician)
+void ServiceBooking::setAssignedTechnician(const std::string& assignedTechnician)
 {
     m_assignedTechnician = assignedTechnician;
 }
@@ -224,130 +144,3 @@ void ServiceBooking::setDiscountPercentage(double discountPercentage)
 {
     m_discountPercentage = discountPercentage;
 }
-
-/*
-Function: getServiceIDsAsString (static helper)
-Description: Converts a vector of service IDs into a single string separated by '|'.
-Parameters:
-    - serviceIDs: const util::Vector<std::string>&, vector of service IDs
-Returns:
-    - std::string: Concatenated service IDs string
-*/
-static std::string getServiceIDsAsString(const util::Vector<std::string>& serviceIDs)
-{
-    int numberOfServices = serviceIDs.getSize();
-    std::string serviceIDsString;
-    for (int index = 0; index < numberOfServices; index++)
-    {
-        serviceIDsString += serviceIDs[index];
-        if (index < numberOfServices - 1)
-        {
-            serviceIDsString += '|';
-        }
-    }
-    return serviceIDsString;
-}
-
-/*
-Function: getServiceIDsAsVector (static helper)
-Description: Converts a string of service IDs separated by '|' into a vector.
-Parameters:
-    - serviceIDsString: const std::string&, concatenated service IDs string
-Returns:
-    - util::Vector<std::string>: Vector of service IDs
-*/
-static util::Vector<std::string> getServiceIDsAsVector(const std::string& serviceIDsString)
-{
-    util::Vector<std::string> serviceIDs;
-    std::string serviceID;
-    std::istringstream serializedServiceIDs(serviceIDsString);
-    while (getline(serializedServiceIDs, serviceID, '|'))
-    {
-        serviceIDs.push_back(serviceID);
-    }
-    return serviceIDs;
-}
-
-/*
-Function: serialize
-Description: Serializes the service booking into a CSV-formatted string.
-Parameters:
-    - None
-Returns:
-    - std::string: Serialized booking record
-*/
-std::string ServiceBooking::serialize() const
-{
-    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 CSV-formatted string into a ServiceBooking object.
-Parameters:
-    - 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 std::string& record)
-{
-    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>(
-        id,
-        status,
-        serviceIDs,
-        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

@@ -1,7 +1,6 @@
 #pragma once
 #include <string>
 #include "Map.h"
-#include "Vector.h"
 #include "Enums.h"
 
 class Service;
@@ -13,7 +12,6 @@ private:
     static int m_uid;
     std::string m_id;
     util::ServiceJobStatus m_status;
-    util::Vector<std::string> m_serviceIDs;
     util::Map<std::string, Service*> m_services;
     std::string m_customerId;
     User* m_customer;
@@ -21,11 +19,12 @@ private:
     std::string m_vehicleBrand;
     std::string m_vehicleModel;
     std::string m_assignedTechnicianId;
-    User* m_assignedTechnician;
+    std::string m_assignedTechnician;
     double m_discountPercentage;
 public:
     ServiceBooking();
     ServiceBooking(
+        const std::string& id,
         util::ServiceJobStatus status,
         const util::Map<std::string,
         Service*>& services,
@@ -35,23 +34,11 @@ public:
         const std::string& vehicleBrand,
         const std::string& vehicleModel,
         const std::string& assignedTechnicianId,
-        User* assignedTechnician,
+        const std::string& assignedTechnician,
-        double discountPercentage
-    );
-    ServiceBooking(
-        const std::string& id,
-        util::ServiceJobStatus status,
-        const util::Vector<std::string>& serviceIDs,
-        const std::string& customerId,
-        const std::string& vehicleNumber,
-        const std::string& vehicleBrand,
-        const std::string& vehicleModel,
-        const std::string& assignedTechnicianId,
         double discountPercentage
     );
     const std::string& getId() const;
     util::ServiceJobStatus getStatus() const;
-    const util::Vector<std::string>& getServiceIDs() const;
     const util::Map<std::string, Service*>& getServices() const;
     const std::string& getCustomerId() const;
     User* getCustomer() const;
@@ -59,7 +46,7 @@ public:
     const std::string& getVehicleBrand() const;
     const std::string& getVehicleModel() const;
     const std::string& getAssignedTechnicianId() const;
-    const User* getAssignedTechnician() const;
+    const std::string& getAssignedTechnician() const;
     double getDiscountPercentage() const;
     void setId(const std::string& id);
     void setStatus(const util::ServiceJobStatus& status);
@@ -70,9 +57,6 @@ public:
     void setVehicleBrand(const std::string& vehicleBrand);
     void setVehicleModel(const std::string& vehicleModel);
     void setAssignedTechnicianId(const std::string& assignedTechnicianId);
-    void setAssignedTechnician(User* assignedTechnician);
+    void setAssignedTechnician(const std::string& assignedTechnician);
     void setDiscountPercentage(double discountPercentage);
-    std::string serialize() const;
-    static ServiceBooking* deserialize(const std::string&);
-    static std::string getHeaders();
 };

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

@@ -1,9 +1,6 @@
-#include <sstream>
 #include "User.h"
 #include "Notification.h"
 #include "Enums.h"
-#include "Factory.h"
-#include "StringHelper.h"
 
 int User::m_uid = 0;
 
@@ -22,45 +19,11 @@ User::User(const std::string& userName, const std::string& password, const std::
     m_type(role),
     m_status(util::State::ACTIVE) {}
 
-/*
-Function: User (parameterized constructor with ID)
-Description: Initializes a user with an existing ID, credentials, personal details,
-             role, and state. Updates UID tracking based on ID.
-Parameters:
-    - userId: const std::string&, unique user ID
-    - userName: const std::string&, username
-    - password: const std::string&, password
-    - name: const std::string&, full name
-    - phone: const std::string&, phone number
-    - email: const std::string&, email address
-    - role: util::UserType, role of the user
-    - status: util::State, state of the user (ACTIVE/INACTIVE)
-Returns:
-    - A new User object
-*/
-User::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)
-    : m_id(userId),
-    m_userName(userName),
-    m_password(password),
-    m_name(name),
-    m_phone(phone),
-    m_email(email),
-    m_type(role),
-    m_status(status)
-{
-    int idNumber = util::extractNumber(m_id);
-    if (idNumber > m_uid)
-    {
-        m_uid = idNumber;
-    }
-}
-
 User::~User()
 {
-    auto values = m_notifications.getValues();
+    for (int index = 0; index < m_notifications.getSize(); index++)
-    for (int index = 0; index < values.getSize(); index++)
     {
-        delete values[index];
+        delete m_notifications.getValues()[index];
     }
 }
 
@@ -157,71 +120,3 @@ void User::setState(util::State status)
 void User::update(Notification* notification)
 {
 }
-
-/*
-Function: serialize
-Description: Serializes the user into a CSV-formatted string.
-Parameters:
-    - None
-Returns:
-    - std::string: Serialized user record
-*/
-std::string User::serialize() const
-{
-    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 CSV-formatted string into a User object.
-Parameters:
-    - record: const std::string&, serialized user record
-Returns:
-    - User*: Pointer to the deserialized User object
-*/
-User* User::deserialize(const std::string& record)
-{
-    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

@@ -22,7 +22,6 @@ private:
 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();
     const std::string& getId() const;
     const std::string& getUserName() const;
@@ -43,7 +42,4 @@ public:
     void setRole(util::UserType role);
     void setState(util::State status);
     void update(Notification* notification) override;
-    std::string serialize() const;
-    static User* deserialize(const std::string&);
-    static std::string getHeaders();
 };

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

@@ -1,104 +1,93 @@
 /*
 File: InventoryManagementService.cpp
-Description: Implements the InventoryManagementService class, which manages inventory
+Description: Implementation file containing the method definitions of the
-			 items and observer relationships within the system. Provides methods
+             InventoryManagementService class, including inventory operations
-			 for loading and saving inventory items from persistent storage, as well
+             and notification handling.
-			 as attaching and persisting observers for notification handling.
 Author: Trenser
-Date: 22-May-2026
+Date:19-May-2026
 */
-
 #include "InventoryManagementService.h"
-#include "FileManager.h"
 #include "InventoryItem.h"
-#include "Utility.h"
+#include "Factory.h"
-#include "Config.h"
 
 /*
-Function: getObserverIDs
+Function: addInventoryItem
-Description: Retrieves the IDs of all observers currently attached to the
+Description: Creates a new inventory item using the Factory and inserts it
-			 InventoryManagementService.
+             into the DataStore.
-Parameters:
+Parameter: const std::string& partName - name of the part
-	- None
+           int quantity - initial quantity of the part
-Returns:
+           double price - price of the part
-	- util::Vector<std::string>: Vector of observer user IDs
+Return type: void
 */
-util::Vector<std::string> InventoryManagementService::getObserverIDs()
+void InventoryManagementService::addInventoryItem(const std::string& partName, int quantity, double price)
 {
-	util::Vector<std::string> observerIDs;
+    InventoryItem* newItem = Factory::getObject<InventoryItem>(partName, quantity, price);
-	int numberOfObservers = m_observers.getSize();
+    m_dataStore.getInventoryItems().insert(newItem->getId(), newItem);
-	for (int index = 0; index < numberOfObservers; index++)
+}
+
+/*
+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)
+{
+    int index = m_dataStore.getInventoryItems().find(selectedItemId);
+    if (index != -1)
     {
-		User* observer = m_observers.getValueAt(index);
+        InventoryItem* item = m_dataStore.getInventoryItems().getValueAt(index);
-		if (observer)
+        if (item != nullptr)
         {
-			observerIDs.push_back(observer->getId());
+            int totalQuantity = item->getQuantity() + quantity;
+            item->setQuantity(totalQuantity);
         }
     }
-	return observerIDs;
 }
 
 /*
-Function: loadInventoryItems
+Function: getInventoryItems
-Description: Loads inventory items from persistent storage into the datastore.
+Description: Retrieves all inventory items stored in the DataStore.
-			 Uses FileManager to deserialize inventory items from the configured file.
+Parameter: None
-Parameters:
+Return type: util::Map<std::string, InventoryItem*>
-	- None
-Returns:
-	- void
 */
-void InventoryManagementService::loadInventoryItems()
+util::Map<std::string, InventoryItem*> InventoryManagementService::getInventoryItems()
 {
-	util::FileManager<InventoryItem> inventoryItemFileManager(config::file::INVENTORYITEM_FILE);
+	return m_dataStore.getInventoryItems();
-	auto& inventoryItems = m_dataStore.getInventoryItems();
+}
-	auto inventoryItemsMap = inventoryItemFileManager.load();
+
-	int numberOfInventoryItems = inventoryItemsMap.getSize();
+/*
-	for (int index = 0; index < numberOfInventoryItems; index++)
+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)
+{
+    int index = m_dataStore.getInventoryItems().find(inventoryItemID);
+    if (index != -1)
     {
-		inventoryItems[inventoryItemsMap.getKeyAt(index)] = inventoryItemsMap.getValueAt(index);
+        InventoryItem* item = m_dataStore.getInventoryItems().getValueAt(index);
+        if (item != nullptr)
+        {
+            item->setState(util::State::INACTIVE);
+        }
     }
 }
 
 /*
-Function: saveInventoryItems
+Function: getInventoryItem
-Description: Saves inventory items from the datastore to persistent storage.
+Description: Retrieves a specific inventory item by its ID from the DataStore.
-			 Uses FileManager to serialize inventory items into the configured file.
+Parameter: const std::string& inventoryItemID - ID of the inventory item
-Parameters:
+Return type: InventoryItem*
-	- None
-Returns:
-	- void
 */
-void InventoryManagementService::saveInventoryItems()
+InventoryItem* InventoryManagementService::getInventoryItem(const std::string& inventoryItemID)
 {
-	util::FileManager<InventoryItem> inventoryItemFileManager(config::file::INVENTORYITEM_FILE);
+    int index = m_dataStore.getInventoryItems().find(inventoryItemID);
-	auto& inventoryItems = m_dataStore.getInventoryItems();
+    if (index != -1)
-	inventoryItemFileManager.save(inventoryItems);
+    {
-}
+        return m_dataStore.getInventoryItems().getValueAt(index);
-
+    }
-/*
+    return nullptr;
-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,7 +1,14 @@
+/*
+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.
+Author: Trenser
+Date:19-May-2026
+*/
 #pragma once
 #include <string>
 #include "Map.h"
-#include "Vector.h"
 #include "NotificationManagementService.h"
 #include "DataStore.h"
 
@@ -12,19 +19,15 @@ 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.h

@@ -10,5 +10,4 @@ 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

@@ -1,123 +1 @@
-#include <stdexcept>
 #include "PaymentManagementService.h"
-#include "Invoice.h"
-#include "FileManager.h"
-#include "Utility.h"
-#include "Config.h"
-
-/*
-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);
-}

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

@@ -13,7 +13,6 @@ 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);
@@ -23,8 +22,4 @@ 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();
 };

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

@@ -1,326 +1 @@
-#include <stdexcept>
 #include "ServiceManagementService.h"
-#include "FileManager.h"
-#include "Service.h"
-#include "ComboPackage.h"
-#include "ServiceBooking.h"
-#include "JobCard.h"
-#include "Config.h"
-#include "Utility.h"
-
-/*
-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);
-}

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

@@ -14,7 +14,6 @@ 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();
@@ -35,14 +34,4 @@ 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();
 };

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

@@ -1,73 +1 @@
 #include "UserManagementService.h"
-#include "FileManager.h"
-#include "User.h"
-#include "Notification.h"
-#include "Config.h"
-
-/*
-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);
-}

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

@@ -21,6 +21,4 @@ public:
     void removeUser(const std::string& userID);
     util::Vector<Notification*> getUserNotifications(const std::string& userID);
     void deleteNotification(const std::string& notificationID, const std::string& userID);
-    void loadUsers();
-    void saveUsers();
 };

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

@@ -1,19 +0,0 @@
-#pragma once
-
-namespace config
-{
-	namespace file
-	{
-		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

@@ -147,9 +147,9 @@ namespace util
         switch (status)
         {
         case State::ACTIVE:
-            return "ACTIVE";
+            return "STARTED";
         case State::INACTIVE:
-            return "INACTIVE";
+            return "COMPLETED";
         }
         throw std::invalid_argument("Invalid State");
     }
@@ -160,7 +160,7 @@ namespace util
         {
             return State::ACTIVE;
         }
-        if (value == "INACTIVE")
+        if (value == "COMPLETED")
         {
             return State::INACTIVE;
         }

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

@@ -1,79 +0,0 @@
-/*
-File: FileHelper.h
-Description: Provides utility functions for loading and saving records
-             from and to CSV-like text files. Ensures files are created
-             if missing and supports simple record persistence.
-Author: Trenser
-Date: 22-May-2026
-*/
-
-#pragma once
-#include <fstream>
-#include <string>
-#include <stdexcept>
-#include "Vector.h"
-
-namespace util
-{
-    /*
-    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&, 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:
-        - std::runtime_error if the file cannot be opened for writing
-    */
-    inline void saveRecords(const std::string& filePath, const util::Vector<std::string>& records)
-    {
-        std::ofstream file(filePath, std::ios::trunc);
-        if (!file.is_open())
-        {
-            throw std::runtime_error("Failed to open file " + filePath);
-        }
-        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

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

@@ -34,7 +34,7 @@ namespace util
 
     /*
      * Function: read
-     * Description: Reads a line of text input from console into a string and cleans it up.
+     * Description: Reads a line of text input from console into a string.
      * Parameters:
      *     value - reference to a string where the input will be stored
      * Returns:
@@ -43,15 +43,6 @@ namespace util
     inline void read(std::string& value)
     {
         std::getline(std::cin >> std::ws, value);
-        std::string cleanedValue;
-        for (int index = 0; index < value.length(); index++)
-        {
-            if (value[index] != ',')
-            {
-                cleanedValue += value[index];
-            }
-        }
-        value = cleanedValue;
     }
 
     /*

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/StringHelper.h

@@ -1,36 +0,0 @@
-/*
-File: StringHelper.h
-Description: Provides utility functions for extracting numeric values from strings.
-             Useful for parsing IDs, codes, or mixed alphanumeric inputs where
-             digits need to be isolated and converted into integers.
-Author: Trenser
-Date: 22-May-2026
-*/
-
-#include <cctype>
-#include <string>
-
-namespace util
-{
-    /*
-    Function: extractNumber
-    Description: Extracts all digits from the given string and converts them into an integer.
-                 Ignores non-digit characters. For example, "abc123xyz" returns 123.
-    Parameters:
-        - input: const std::string&, the input string containing digits and/or other characters
-    Returns:
-        - int: The integer value formed by concatenating all digits in the string
-    */
-    inline int extractNumber(const std::string& input)
-    {
-        int result = 0;
-        for (char character : input)
-        {
-            if (std::isdigit(static_cast<unsigned char>(character)))
-            {
-                result = result * 10 + (character - '0');
-            }
-        }
-        return result;
-    }
-}

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

@@ -1,63 +0,0 @@
-/*
-File: ObserversHelper.h
-Description: Provides utility functions for loading and saving observers
-             in the notification management system. Ensures that observer
-             IDs are validated against existing users in the datastore
-             before attaching them to the notification service.
-Author: Trenser
-Date: 22-May-2026
-*/
-
-#pragma once
-#include "NotificationManagementService.h"
-#include "FileHelper.h"
-#include "DataStore.h"
-
-namespace util
-{
-    /*
-    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:
-        - 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:
-        - void
-    Throws:
-        - std::runtime_error if an observer ID is invalid (not found in datastore)
-    */
-    inline void loadObservers(const std::string& filePath, NotificationManagementService* service, DataStore& dataStore)
-    {
-        auto observerIDs = util::loadRecords(filePath);
-        auto& users = dataStore.getUsers();
-        for (int index = 0; index < observerIDs.getSize(); index++)
-        {
-            const std::string& observerID = observerIDs[index];
-            int userIndex = users.find(observerID);
-            if (userIndex == -1)
-            {
-                throw std::runtime_error("Invalid Observer ID");
-            }
-            service->attach(users.getValueAt(userIndex));
-        }
-    }
-
-    /*
-    Function: saveObservers
-    Description: Saves the current observer IDs from the notification management service
-                 to a file for persistence.
-    Parameters:
-        - filePath: const std::string&, path to the file where observer IDs will be saved
-        - service: NotificationManagementService*, pointer to the notification service
-    Returns:
-        - void
-    */
-    inline void saveObservers(const std::string& filePath, NotificationManagementService* service)
-    {
-        auto observerIDs = service->getObserverIDs();
-        util::saveRecords(filePath, observerIDs);
-    }
-}

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

@@ -1,7 +1,23 @@
+/*
+File: AdminMenu.cpp
+Description: Implementation file containing the method definitions of the
+             AdminMenu class, including menu handling, inventory operations,
+             and stock management functions.
+Author: Trenser
+Date:19-May-2026
+*/
+#include <iomanip>
 #include "AdminMenu.h"
+#include "InventoryItem.h"
 #include "InputHelper.h"
 #include "OutputHelper.h"
 
+/*
+Function: showMenu
+Description: Displays the admin menu and handles user input until the menu is exited.
+Parameter: None
+Return type: void
+*/
 void AdminMenu::showMenu()
 {
 	bool isMenuActive = true;
@@ -40,20 +56,252 @@ void AdminMenu::changePassword()
 {
 }
 
+/*
+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()
 {
+	auto inventoryItems = m_controller.getInventoryItems();
+	std::cout << std::left << std::setw(15) << "Item ID"
+		<< std::setw(25) << "Part Name"
+		<< std::setw(10) << "Quantity"
+		<< std::setw(10) << "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(10) << item->getQuantity()
+					<< std::setw(10) << item->getPrice()
+					<< std::endl;
+			}
+		}
+	}
 }
 
+/*
+Function: filterActiveItems
+Description: Filters out inactive inventory items and returns a map
+             containing only active items.
+Parameter: const util::Map<std::string, const InventoryItem*>& inventoryItems -
+           map of all inventory items
+Return type: util::Map<std::string, const InventoryItem*>
+*/
+static util::Map<std::string, const InventoryItem*>
+filterActiveItems(const util::Map<std::string, const InventoryItem*>& inventoryItems)
+{
+    util::Map<std::string, const InventoryItem*> activeItems;
+    int inventorySize = inventoryItems.getSize();
+    for (int index = 0; index < inventorySize; index++)
+    {
+        const InventoryItem* item = inventoryItems.getValueAt(index);
+        if (item != nullptr && item->getState() != util::State::INACTIVE)
+        {
+            activeItems.insert(item->getId(), item);
+        }
+    }
+    return activeItems;
+}
+
+/*
+Function: displayInventoryWithItems
+Description: Displays inventory items in a tabular format with index, ID,
+             part name, quantity, and price.
+Parameter: util::Map<std::string, const InventoryItem*>& inventoryItems -
+           map of inventory items to display
+Return type: void
+*/
+static void displayInventoryWithItems(util::Map<std::string, const InventoryItem*>& inventoryItems)
+{
+    int inventorySize = inventoryItems.getSize();
+    std::cout << std::left << std::setw(10) << "Index"
+        << std::setw(15) << "Item ID"
+        << std::setw(25) << "Part Name"
+        << std::setw(10) << "Quantity"
+        << std::setw(10) << "Price"
+        << std::endl;
+    for (int iterator = 0; iterator < inventorySize; iterator++)
+    {
+        const InventoryItem* item = inventoryItems.getValueAt(iterator);
+        if (item != nullptr)
+        {
+            std::cout << std::left << std::setw(10) << (iterator + 1)
+                << std::setw(15) << item->getId()
+                << std::setw(25) << item->getPartName()
+                << std::setw(10) << item->getQuantity()
+                << std::setw(10) << item->getPrice()
+                << std::endl;
+        }
+    }
+}
+
+/*
+Function: addQuantityToItem
+Description: Allows the admin to select an active inventory item and
+             increase its stock quantity.
+Parameter: util::Map<std::string, const InventoryItem*>& inventoryItems -
+           map of inventory items
+           Controller& m_controller - controller instance to update stock
+Return type: void
+*/
+static void addQuantityToItem(util::Map<std::string, const InventoryItem*>& inventoryItems, Controller& m_controller)
+{
+    int itemIndex;
+    int quantity;
+    auto activeItems = filterActiveItems(inventoryItems);
+    int activeSize = activeItems.getSize();
+    if (activeSize == 0)
+    {
+        std::cout << "No active items available in Inventory" << std::endl;
+        return;
+    }
+    displayInventoryWithItems(activeItems);
+    std::cout << "Enter the index of the item to update: ";
+    util::read(itemIndex);
+    if (itemIndex < 1 || itemIndex > activeSize)
+    {
+        std::cout << "Invalid index selected." << std::endl;
+        return;
+    }
+    std::cout << "Enter quantity to add: ";
+    util::read(quantity);
+    if (quantity < 0)
+    {
+        std::cout << "The quantity should be Greater than 0." << std::endl;
+        return;
+    }
+    const InventoryItem* selectedItem = activeItems.getValueAt(itemIndex - 1);
+    if (selectedItem != nullptr)
+    {
+        std::string selectedItemId = selectedItem->getId();
+        m_controller.addInventoryItemStock(selectedItemId, quantity);
+        std::cout << "Updated " << selectedItem->getPartName()
+            << " stock. New quantity: " << selectedItem->getQuantity()
+            << std::endl;
+    }
+    else
+    {
+        std::cout << "Error: Selected item could not be found." << std::endl;
+    }
+}
+
+/*
+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 << "1. Add new item \n2. Add Quantity\nEnter your choice : ";
+	util::read(choice);
+	switch (choice)
+	{
+	case 1: 
+	{
+		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 << "New Item " << partName << " added to the Inventory.\n";
+		break;
+	}
+	case 2:
+	{
+		auto inventoryItems = m_controller.getInventoryItems();
+		addQuantityToItem(inventoryItems, m_controller);
+		break;
+	}
+	}
+	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();
+    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 = inventoryItems.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;
+        }
+    }
+    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 << "Enter the Item Id : ";
+	util::read(itemId);
+	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";
+		}
+	}
+	util::pressEnter();
 }
 
 void AdminMenu::assignJob()

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

@@ -1,3 +1,11 @@
+/*
+File: AdminMenu.h
+Description: Header file declaring the AdminMenu class, which provides
+             administrative operations such as inventory management,
+             user management, service configuration, and notifications.
+Author: Trenser
+Date:19-May-2026
+*/
 #pragma once
 #include "Controller.h"
 

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

@@ -4,7 +4,6 @@
 
 void UserInterface::run()
 {
-	m_controller.loadSystemData();
 	bool isMenuActive = true;
 	while (isMenuActive)
 	{
@@ -25,7 +24,6 @@ void UserInterface::run()
 			util::pressEnter();
 		}
 	}
-	m_controller.saveSystemData();
 }
 
 bool UserInterface::handleOperation(int choice)