Add standardized documentation headers

<UserStory> CUS001:Login </UserStory>

<Changes>
    1. Added login implementation in AuthenticationManagementService to validate username and password from stored user records.
    2. Connected Controller::login() with AuthenticationManagementService login logic.
    3. Added getAuthenticatedUser() integration in Controller for retrieving the logged-in user.
    4. Implemented login flow in UserInterface to collect credentials and validate login.
    5. Added role-based menu navigation for Admin, Technician, and Customer after successful login.
    6. Added error handling to display "Invalid Username or Password" for failed login attempts.
    7. Added required includes and controller member dependency for authentication support.
    8. Added a check to create a default admin automatically if no admin exists in the system on startup
</Changes>

<Test>

Login functionality validation

Precondition:
1. System is running.
2. User records are available in the data store.
3. Valid username and password exist for a registered user.

Steps:
1. Launch the application.
2. Select the login option from the main menu.
3. Enter a valid username and password.
   - Verify that the entered credentials are validated.
   - Verify that access is granted and the correct menu is shown based on user type.
4. Enter an invalid username or password.
   - Verify that the message "Invalid Username or Password" is displayed.

</Test>

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

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

@@ -173,18 +173,16 @@
     <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" />
     <ClInclude Include="views\CustomerMenu.h" />
+    <ClInclude Include="views\MenuHelper.h" />
     <ClInclude Include="views\TechnicianMenu.h" />
     <ClInclude Include="views\UserInterface.h" />
   </ItemGroup>

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,33 +1,95 @@
+/*
+File: Controller.cpp
+Description: Implementation file containing the method definitions of the
+             Controller class, including authentication, user creation,
+             service purchasing, and system checks.
+Author: Trenser
+Date:19-May-2026
+*/
+#include <stdexcept>
 #include "Controller.h"
+#include "Enums.h"
+#include "User.h"
 
+/*
+Function: login
+Description: Authenticates a user by delegating to the authentication management service.
+Parameter: const std::string& username - user’s username
+           const std::string& password - user’s password
+Return type: bool - true if login successful, false otherwise
+*/
 bool Controller::login(const std::string& username, const std::string& password)
 {
-    return false;
+    return m_authenticationManagementService.login(username, password);
 }
 
+/*
+Function: logout
+Description: Logs out the currently authenticated user.
+Parameter: None
+Return type: void
+*/
 void Controller::logout()
 {
+    m_authenticationManagementService.logout();
 }
 
+/*
+Function: changePassword
+Description: Changes the password of the currently authenticated user.
+Parameter: const std::string& newPassword - new password to set
+Return type: void
+*/
 void Controller::changePassword(const std::string& newPassword)
 {
+    m_authenticationManagementService.changePassword(newPassword);
 }
 
-void Controller::createCustomer(const std::string& username, const std::string& password, const std::string& email, const std::string& phone)
+/*
+Function: createCustomer
+Description: Creates a new customer account with the provided details.
+Parameter: const std::string& username - customer’s username
+           const std::string& name - customer’s name
+           const std::string& password - customer’s password
+           const std::string& email - customer’s email
+           const std::string& phone - customer’s phone number
+Return type: void
+*/
+void Controller::createCustomer(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone)
 {
+    m_userManagementService.createUser(username, name, password, email, phone, util::UserType::CUSTOMER);
 }
 
+/*
+Function: getAuthenticatedUser
+Description: Retrieves the currently authenticated user.
+Parameter: None
+Return type: const User* - pointer to the authenticated user
+*/
 const User* Controller::getAuthenticatedUser()
 {
-    return nullptr;
+    return m_authenticationManagementService.getAuthenticatedUser();
 }
 
 void Controller::createTechnician(const std::string& username, const std::string& password, const std::string& email, const std::string& phone)
 {
 }
 
+/*
+Function: updateUserDetails
+Description: Updates the email and phone details of the currently authenticated user.
+Parameter: const std::string& email - new email address
+           const std::string& phone - new phone number
+Return type: void
+*/
 void Controller::updateUserDetails(const std::string& email, const std::string& phone)
 {
+    User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
+    if (authenticatedUser == nullptr)
+    {
+        throw std::runtime_error("No user currently logged in!");
+    }
+    m_userManagementService.updateUserDetails(authenticatedUser->getId(), email, phone);
 }
 
 util::Map<std::string, const Service*> Controller::getServices()
@@ -40,12 +102,32 @@ util::Map<std::string, const ComboPackage*> Controller::getComboPackages()
     return util::Map<std::string, const ComboPackage*>();
 }
 
+/*
+Function: purchaseService
+Description: Purchases one or more services for a vehicle by delegating to the service management service.
+Parameter: const util::Vector<std::string>& serviceIDs - IDs of services to purchase
+           const std::string& vehicleNumber - vehicle registration number
+           const std::string& vehicleBrand - brand of the vehicle
+           const std::string& vehicleModel - model of the vehicle
+Return type: void
+*/
 void Controller::purchaseService(const util::Vector<std::string>& serviceIDs, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
 {
+    m_serviceManagementService.purchaseService(serviceIDs, vehicleNumber, vehicleBrand, vehicleModel);
 }
 
+/*
+Function: purchaseComboPackage
+Description: Purchases a combo package for a vehicle by delegating to the service management service.
+Parameter: const std::string& comboPackageID - ID of the combo package
+           const std::string& vehicleNumber - vehicle registration number
+           const std::string& vehicleBrand - brand of the vehicle
+           const std::string& vehicleModel - model of the vehicle
+Return type: void
+*/
 void Controller::purchaseComboPackage(const std::string& comboPackageID, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
 {
+    m_serviceManagementService.purchaseComboPackage(comboPackageID, vehicleNumber, vehicleBrand, vehicleModel);
 }
 
 util::Map<std::string, const InventoryItem*> Controller::getInventoryItems()
@@ -142,54 +224,13 @@ void Controller::configureNotifications(const std::string& userID, bool paymentN
 }
 
 /*
-Function: loadSystemData
+Function: runSystemChecks
-Description: Loads all system data from persistent storage into memory.
+Description: Runs system checks to ensure critical configurations, such as verifying admin existence.
-             Invokes the respective management services to load users, inventory items, services,
+Parameter: None
-             combo packages, service bookings, job cards, invoices, and observers.
+Return type: void
-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()
 {
+    m_userManagementService.ensureAdminExists();
 }
 

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

@@ -1,11 +1,18 @@
+/*
+File: Controller.h
+Description: Header file declaring the Controller class, which coordinates
+             authentication, user management, service management, inventory,
+             and notifications across the Vehicle Service System.
+Author: Trenser
+Date:19-May-2026
+*/
 #pragma once
 #include "Map.h"
 #include <string>
 #include "Enums.h"
-#include "InventoryManagementService.h"
+#include "AuthenticationManagementService.h"
 #include "UserManagementService.h"
 #include "ServiceManagementService.h"
-#include "PaymentManagementService.h"
 
 class Service;
 class ComboPackage;
@@ -19,15 +26,14 @@ class Notification;
 class Controller
 {
 private:
+    AuthenticationManagementService m_authenticationManagementService;
     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();
     void changePassword(const std::string& newPassword);
-    void createCustomer(const std::string& username, const std::string& password, const std::string& email, const std::string& phone);
+    void createCustomer(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone);
     const User* getAuthenticatedUser();
     void createTechnician(const std::string& username, const std::string& password, const std::string& email, const std::string& phone);
     void updateUserDetails(const std::string& email, const std::string& phone);
@@ -56,7 +62,5 @@ 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 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,19 +1,42 @@
-#include <stdexcept>
+/*
-#include <sstream>
+File: ServiceBooking.cpp
+Description: Implementation file containing the method definitions of the
+             ServiceBooking class, including constructors, getters, and setters
+             for booking attributes.
+Author: Trenser
+Date:19-May-2026
+*/
 #include "ServiceBooking.h"
-#include "Service.h"
-#include "Enums.h"
-#include "Factory.h"
-#include "StringHelper.h"
 
 int ServiceBooking::m_uid = 0;
 
+/*
+Function: ServiceBooking
+Description: Default constructor that initializes a new service booking
+             with a unique ID, no customer or technician, and zero discount.
+Parameter: None
+Return type: Constructor
+*/
 ServiceBooking::ServiceBooking()
     : m_id("SRV" + std::to_string(++m_uid)),
     m_customer(nullptr),
     m_assignedTechnician(nullptr),
     m_discountPercentage(0.0) {}
 
+/*
+Function: ServiceBooking
+Description: Parameterized constructor that initializes a service booking
+             with customer, vehicle, services, and discount details.
+Parameter: util::ServiceJobStatus status - current booking status
+           const util::Map<std::string, Service*>& services - map of services
+           const std::string& customerId - ID of the customer
+           User* customer - pointer to the customer object
+           const std::string& vehicleNumber - vehicle registration number
+           const std::string& vehicleBrand - brand of the vehicle
+           const std::string& vehicleModel - model of the vehicle
+           double discountPercentage - discount applied to the booking
+Return type: Constructor
+*/
 ServiceBooking::ServiceBooking(
     util::ServiceJobStatus status,
     const util::Map<std::string,
@@ -23,8 +46,6 @@ ServiceBooking::ServiceBooking(
     const std::string& vehicleNumber,
     const std::string& vehicleBrand,
     const std::string& vehicleModel,
-    const std::string& assignedTechnicianId,
-    User* assignedTechnician,
     double discountPercentage
 )
     : m_id("SRV" + std::to_string(++m_uid)),
@@ -35,319 +56,249 @@ ServiceBooking::ServiceBooking(
     m_vehicleNumber(vehicleNumber),
     m_vehicleBrand(vehicleBrand),
     m_vehicleModel(vehicleModel),
-    m_assignedTechnicianId(assignedTechnicianId),
+    m_assignedTechnicianId(""),
-    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;
-    }
 }
 
+/*
+Function: getId
+Description: Retrieves the unique identifier of the service booking.
+Parameter: None
+Return type: const std::string&
+*/
 const std::string& ServiceBooking::getId() const
 {
     return m_id;
 }
 
+/*
+Function: getStatus
+Description: Retrieves the current status of the service booking.
+Parameter: None
+Return type: util::ServiceJobStatus
+*/
 util::ServiceJobStatus ServiceBooking::getStatus() const
 {
     return m_status;
 }
 
 /*
-Function: getServiceIDs
+Function: getServices
-Description: Retrieves the IDs of services booked.
+Description: Retrieves the services associated with the booking.
-Parameters:
+Parameter: None
-    - None
+Return type: const util::Map<std::string, Service*>&
-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;
 }
 
+/*
+Function: getCustomerId
+Description: Retrieves the customer ID associated with the booking.
+Parameter: None
+Return type: const std::string&
+*/
 const std::string& ServiceBooking::getCustomerId() const
 {
     return m_customerId;
 }
 
+/*
+Function: getCustomer
+Description: Retrieves the customer object associated with the booking.
+Parameter: None
+Return type: User*
+*/
 User* ServiceBooking::getCustomer() const
 {
     return m_customer;
 }
 
+/*
+Function: getVehicleNumber
+Description: Retrieves the vehicle registration number for the booking.
+Parameter: None
+Return type: const std::string&
+*/
 const std::string& ServiceBooking::getVehicleNumber() const
 {
     return m_vehicleNumber;
 }
 
+/*
+Function: getVehicleBrand
+Description: Retrieves the brand of the vehicle for the booking.
+Parameter: None
+Return type: const std::string&
+*/
 const std::string& ServiceBooking::getVehicleBrand() const
 {
     return m_vehicleBrand;
 }
 
+/*
+Function: getVehicleModel
+Description: Retrieves the model of the vehicle for the booking.
+Parameter: None
+Return type: const std::string&
+*/
 const std::string& ServiceBooking::getVehicleModel() const
 {
     return m_vehicleModel;
 }
 
+/*
+Function: getAssignedTechnicianId
+Description: Retrieves the ID of the technician assigned to the booking.
+Parameter: None
+Return type: const std::string&
+*/
 const std::string& ServiceBooking::getAssignedTechnicianId() const
 {
     return m_assignedTechnicianId;
 }
 
-const User* ServiceBooking::getAssignedTechnician() const
+/*
+Function: getAssignedTechnician
+Description: Retrieves the technician object assigned to the booking.
+Parameter: None
+Return type: User*
+*/
+User* ServiceBooking::getAssignedTechnician() const
 {
     return m_assignedTechnician;
 }
-
+/*
+Function: getDiscountPercentage
+Description: Retrieves the discount percentage applied to the booking.
+Parameter: None
+Return type: double
+*/
 double ServiceBooking::getDiscountPercentage() const
 {
     return m_discountPercentage;
 }
 
+/*
+Function: setId
+Description: Sets the unique identifier of the service booking.
+Parameter: const std::string& id - new booking ID
+Return type: void
+*/
 void ServiceBooking::setId(const std::string& id)
 {
     m_id = id;
 }
 
+/*
+Function: setStatus
+Description: Sets the current status of the service booking.
+Parameter: const util::ServiceJobStatus& status - new booking status
+Return type: void
+*/
 void ServiceBooking::setStatus(const util::ServiceJobStatus& status)
 {
     m_status = status;
 }
 
+/*
+Function: setServices
+Description: Sets the services associated with the booking.
+Parameter: const util::Map<std::string, Service*>& services - new services map
+Return type: void
+*/
 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());
-    }
 }
 
+/*
+Function: setCustomerId
+Description: Sets the customer ID for the booking.
+Parameter: const std::string& customerId - new customer ID
+Return type: void
+*/
 void ServiceBooking::setCustomerId(const std::string& customerId)
 {
     m_customerId = customerId;
 }
 
+/*
+Function: setCustomer
+Description: Sets the customer object for the booking.
+Parameter: User* customer - pointer to the customer object
+Return type: void
+*/
 void ServiceBooking::setCustomer(User* customer)
 {
     m_customer = customer;
 }
 
+/*
+Function: setVehicleNumber
+Description: Sets the vehicle registration number for the booking.
+Parameter: const std::string& vehicleNumber - new vehicle number
+Return type: void
+*/
 void ServiceBooking::setVehicleNumber(const std::string& vehicleNumber)
 {
     m_vehicleNumber = vehicleNumber;
 }
 
+/*
+Function: setVehicleBrand
+Description: Sets the brand of the vehicle for the booking.
+Parameter: const std::string& vehicleBrand - new vehicle brand
+Return type: void
+*/
 void ServiceBooking::setVehicleBrand(const std::string& vehicleBrand)
 {
     m_vehicleBrand = vehicleBrand;
 }
 
+/*
+Function: setVehicleModel
+Description: Sets the model of the vehicle for the booking.
+Parameter: const std::string& vehicleModel - new vehicle model
+Return type: void
+*/
 void ServiceBooking::setVehicleModel(const std::string& vehicleModel)
 {
     m_vehicleModel = vehicleModel;
 }
 
+/*
+Function: setAssignedTechnicianId
+Description: Sets the ID of the technician assigned to the booking.
+Parameter: const std::string& assignedTechnicianId - new technician ID
+Return type: void
+*/
 void ServiceBooking::setAssignedTechnicianId(const std::string& assignedTechnicianId)
 {
     m_assignedTechnicianId = assignedTechnicianId;
 }
 
+/*
+Function: setAssignedTechnician
+Description: Sets the technician object assigned to the booking.
+Parameter: User* assignedTechnician - pointer to the technician object
+Return type: void
+*/
 void ServiceBooking::setAssignedTechnician(User* assignedTechnician)
 {
     m_assignedTechnician = assignedTechnician;
 }
 
+/*
+Function: setDiscountPercentage
+Description: Sets the discount percentage for the booking.
+Parameter: double discountPercentage - new discount percentage
+Return type: void
+*/
 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,14 @@
+/*
+File: ServiceBooking.h
+Description: Header file declaring the ServiceBooking class, which represents
+             a booking of services by a customer, including vehicle details,
+             assigned technician, and discount information.
+Author: Trenser
+Date:19-May-2026
+*/
 #pragma once
 #include <string>
 #include "Map.h"
-#include "Vector.h"
 #include "Enums.h"
 
 class Service;
@@ -13,7 +20,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;
@@ -34,24 +40,10 @@ public:
         const std::string& vehicleNumber,
         const std::string& vehicleBrand,
         const std::string& vehicleModel,
-        const std::string& assignedTechnicianId,
-        User* 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 +51,7 @@ public:
     const std::string& getVehicleBrand() const;
     const std::string& getVehicleModel() const;
     const std::string& getAssignedTechnicianId() const;
-    const User* getAssignedTechnician() const;
+    User* getAssignedTechnician() const;
     double getDiscountPercentage() const;
     void setId(const std::string& id);
     void setStatus(const util::ServiceJobStatus& status);
@@ -72,7 +64,4 @@ public:
     void setAssignedTechnicianId(const std::string& assignedTechnicianId);
     void setAssignedTechnician(User* 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/AuthenticationManagementService.cpp

@@ -1,3 +1,81 @@
+/*
+File: AuthenticationManagementService.cpp
+Description: Implementation file containing the method definitions of the
+			 AuthenticationManagementService class, including login, logout,
+			 password change, and retrieval of the authenticated user.
+Author: Trenser
+Date:19-May-2026
+*/
+#include <stdexcept>
 #include "AuthenticationManagementService.h"
+#include "User.h"
 
 User* AuthenticationManagementService::m_authenticatedUser = nullptr;
+
+/*
+Function: login
+Description: Authenticates a user by checking the provided username and password
+			 against the stored users in the DataStore. If successful, sets the
+			 authenticated user.
+Parameter: const std::string& username - user’s username
+		   const std::string& password - user’s password
+Return type: bool - true if login successful, false otherwise
+*/
+bool AuthenticationManagementService::login(const std::string& username, const std::string& password)
+{
+	util::Map<std::string, User*> users = m_dataStore.getUsers();
+	int usersMapSize = users.getSize();
+	for (int index = 0; index < usersMapSize; index++)
+	{
+		User* user = users.getValueAt(index);
+		if (username == user->getUserName())
+		{
+			if (password == user->getPassword())
+			{
+				m_authenticatedUser = user;
+				return true;
+			}
+			return false;
+		}
+	}
+	return false;
+}
+
+/*
+Function: getAuthenticatedUser
+Description: Retrieves the currently authenticated user.
+Parameter: None
+Return type: User* - pointer to the authenticated user
+*/
+User* AuthenticationManagementService::getAuthenticatedUser()
+{
+	return m_authenticatedUser;
+}
+
+/*
+Function: logout
+Description: Logs out the currently authenticated user by clearing the
+			 static authenticated user pointer.
+Parameter: None
+Return type: void
+*/
+void AuthenticationManagementService::logout()
+{
+	m_authenticatedUser = nullptr;
+}
+
+/*
+Function: changePassword
+Description: Changes the password of the currently authenticated user.
+			 Throws an exception if no user is logged in.
+Parameter: const std::string& newPassword - new password to set
+Return type: void
+*/
+void AuthenticationManagementService::changePassword(const std::string& newPassword)
+{
+	if (m_authenticatedUser == nullptr)
+	{
+		throw std::runtime_error("There is no user currently logged in!");
+	}
+	m_authenticatedUser->setPassword(newPassword);
+}

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

@@ -1,3 +1,11 @@
+/*
+File: AuthenticationManagementService.h
+Description: Header file declaring the AuthenticationManagementService class, which manages
+             user authentication, login, logout, password changes, and retrieval of the
+             authenticated user.
+Author: Trenser
+Date:19-May-2026
+*/
 #pragma once
 #include <string>
 #include "DataStore.h"

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

@@ -1,104 +1 @@
-/*
-File: InventoryManagementService.cpp
-Description: Implements the InventoryManagementService class, which manages inventory
-			 items and observer relationships within the system. Provides methods
-			 for loading and saving inventory items from persistent storage, as well
-			 as attaching and persisting observers for notification handling.
-Author: Trenser
-Date: 22-May-2026
-*/
-
 #include "InventoryManagementService.h"
-#include "FileManager.h"
-#include "InventoryItem.h"
-#include "Utility.h"
-#include "Config.h"
-
-/*
-Function: getObserverIDs
-Description: Retrieves the IDs of all observers currently attached to the
-			 InventoryManagementService.
-Parameters:
-	- None
-Returns:
-	- util::Vector<std::string>: Vector of observer user IDs
-*/
-util::Vector<std::string> InventoryManagementService::getObserverIDs()
-{
-	util::Vector<std::string> observerIDs;
-	int numberOfObservers = m_observers.getSize();
-	for (int index = 0; index < numberOfObservers; index++)
-	{
-		User* observer = m_observers.getValueAt(index);
-		if (observer)
-		{
-			observerIDs.push_back(observer->getId());
-		}
-	}
-	return observerIDs;
-}
-
-/*
-Function: loadInventoryItems
-Description: Loads inventory items from persistent storage into the datastore.
-			 Uses FileManager to deserialize inventory items from the configured file.
-Parameters:
-	- None
-Returns:
-	- void
-*/
-void InventoryManagementService::loadInventoryItems()
-{
-	util::FileManager<InventoryItem> inventoryItemFileManager(config::file::INVENTORYITEM_FILE);
-	auto& inventoryItems = m_dataStore.getInventoryItems();
-	auto inventoryItemsMap = inventoryItemFileManager.load();
-	int numberOfInventoryItems = inventoryItemsMap.getSize();
-	for (int index = 0; index < numberOfInventoryItems; index++)
-	{
-		inventoryItems[inventoryItemsMap.getKeyAt(index)] = inventoryItemsMap.getValueAt(index);
-	}
-}
-
-/*
-Function: saveInventoryItems
-Description: Saves inventory items from the datastore to persistent storage.
-			 Uses FileManager to serialize inventory items into the configured file.
-Parameters:
-	- None
-Returns:
-	- void
-*/
-void InventoryManagementService::saveInventoryItems()
-{
-	util::FileManager<InventoryItem> inventoryItemFileManager(config::file::INVENTORYITEM_FILE);
-	auto& inventoryItems = m_dataStore.getInventoryItems();
-	inventoryItemFileManager.save(inventoryItems);
-}
-
-/*
-Function: loadObservers
-Description: Loads observer IDs from persistent storage and attaches corresponding
-			 users as observers to the InventoryManagementService.
-Parameters:
-	- None
-Returns:
-	- void
-*/
-void InventoryManagementService::loadObservers()
-{
-	util::loadObservers(config::file::INVENTORYMANAGEMENTOBSERVERS, this, m_dataStore);
-}
-
-/*
-Function: saveObservers
-Description: Saves the current observer IDs of the InventoryManagementService
-			 to persistent storage for future retrieval.
-Parameters:
-	- None
-Returns:
-	- void
-*/
-void InventoryManagementService::saveObservers()
-{
-	util::saveObservers(config::file::INVENTORYMANAGEMENTOBSERVERS, this);
-}

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

@@ -1,7 +1,6 @@
 #pragma once
 #include <string>
 #include "Map.h"
-#include "Vector.h"
 #include "NotificationManagementService.h"
 #include "DataStore.h"
 
@@ -12,7 +11,6 @@ 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();
@@ -23,8 +21,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 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,98 @@
+/*
+File: ServiceManagementService.cpp
+Description: Implementation file containing the method definitions of the
+			 ServiceManagementService class, including service and combo package
+			 purchasing logic, booking creation, and notification handling.
+Author: Trenser
+Date:19-May-2026
+*/
 #include <stdexcept>
 #include "ServiceManagementService.h"
-#include "FileManager.h"
+#include "AuthenticationManagementService.h"
 #include "Service.h"
-#include "ComboPackage.h"
 #include "ServiceBooking.h"
-#include "JobCard.h"
+#include "ComboPackage.h"
-#include "Config.h"
+#include "Factory.h"
-#include "Utility.h"
 
 /*
-Function: getObserverIDs
+Function: purchaseService
-Description: Retrieves the IDs of all observers currently attached to the
+Description: Creates a new service booking for the authenticated user. Validates
-             ServiceManagementService.
+			 service IDs, retrieves services from the DataStore, and generates a
-Parameters:
+			 booking. Sends a notification upon successful booking.
-    - None
+Parameter: const util::Vector<std::string>& serviceIDs - IDs of services to purchase
-Returns:
+		   const std::string& vehicleNumber - vehicle registration number
-    - util::Vector<std::string>: Vector of observer user IDs
+		   const std::string& vehicleBrand - brand of the vehicle
+		   const std::string& vehicleModel - model of the vehicle
+Return type: void
 */
-util::Vector<std::string> ServiceManagementService::getObserverIDs()
+void ServiceManagementService::purchaseService(const util::Vector<std::string>& serviceIDs, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
 {
-	util::Vector<std::string> observerIDs;
+	AuthenticationManagementService m_authenticationManagementService;
-	int numberOfObservers = m_observers.getSize();
+	auto authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
-	for (int index = 0; index < numberOfObservers; index++)
+	if (authenticatedUser == nullptr)
 	{
-		User* observer = m_observers.getValueAt(index);
+		throw std::runtime_error("No user is currently logged in!");
-		if (observer)
-		{
-			observerIDs.push_back(observer->getId());
 	}
-	}
+	auto& servicesMap = m_dataStore.getServices();
-	return observerIDs;
+	auto& serviceBookingMap = m_dataStore.getServiceBookings();
-}
+	util::Map<std::string, Service*> selectedServices;
-
+	int selectedServicesCount = serviceIDs.getSize();
-/*
+	for (int index = 0; index < selectedServicesCount; index++)
-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);
+		int serviceIndex = servicesMap.find(serviceIDs[index]);
-        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");
+			throw std::runtime_error("Service not found!");
 		}
-        Service* service = services.getValueAt(serviceIndex);
+		Service* service = servicesMap.getValueAt(serviceIndex);
-        if (booking->getServices().find(jobCard->getServiceId()) == -1)
+		selectedServices[service->getId()] = service;
+	}
+	ServiceBooking* serviceBooking = Factory::getObject<ServiceBooking>(util::ServiceJobStatus::STARTED, selectedServices, authenticatedUser->getId(), authenticatedUser, vehicleNumber, vehicleBrand, vehicleModel, 0);
+	if (serviceBooking == nullptr)
 	{
-            throw std::runtime_error("Service does not belong to booking");
+		throw std::runtime_error("Failed to create service 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;
 	}
+	serviceBookingMap[serviceBooking->getId()] = serviceBooking;
+	sendNotification(authenticatedUser,
+		"Service Booking succeeded",
+		"Your service booking has been successfully placed with ID " + serviceBooking->getId());
 }
 
 /*
-Function: saveJobCards
+Function: purchaseComboPackage
-Description: Saves job cards from the datastore to persistent storage.
+Description: Creates a new service booking for a combo package. Validates the combo
-             Uses FileManager to serialize job cards into the configured file.
+			 package ID, retrieves services from the package, and generates a booking
-Parameters:
+			 with the applicable discount. Sends a notification upon successful booking.
-    - None
+Parameter: const std::string& comboPackageID - ID of the combo package
-Returns:
+		   const std::string& vehicleNumber - vehicle registration number
-    - void
+		   const std::string& vehicleBrand - brand of the vehicle
+		   const std::string& vehicleModel - model of the vehicle
+Return type: void
 */
-void ServiceManagementService::saveJobCards()
+void ServiceManagementService::purchaseComboPackage(const std::string& comboPackageID, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
 {
-    util::FileManager<JobCard> jobCardFileManager(config::file::JOBCARD_FILE);
+	AuthenticationManagementService m_authenticationManagementService;
-    auto& jobCards = m_dataStore.getJobCards();
+	auto authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
-    jobCardFileManager.save(jobCards);
+	if (authenticatedUser == nullptr)
-}
+	{
-
+		throw std::runtime_error("No user is currently logged in!");
-/*
+	}
-Function: loadObservers
+	auto& comboPackagesMap = m_dataStore.getComboPackages();
-Description: Loads observer IDs from persistent storage and attaches corresponding
+	auto& serviceBookingMap = m_dataStore.getServiceBookings();
-             users as observers to the ServiceManagementService.
+	int comboPackageIndex = comboPackagesMap.find(comboPackageID);
-Parameters:
+	if (comboPackageIndex == -1)
-    - None
+	{
-Returns:
+		throw std::runtime_error("Combo Package not found!");
-    - void
+	}
-Throws:
+	const ComboPackage* comboPackage = comboPackagesMap[comboPackageID];
-    - std::runtime_error if an observer ID is invalid (not found in datastore)
+	util::Map<std::string, Service*> selectedServices = comboPackage->getServices();
-*/
+	ServiceBooking* serviceBooking = Factory::getObject<ServiceBooking>(util::ServiceJobStatus::STARTED, selectedServices, authenticatedUser->getId(), authenticatedUser, vehicleNumber, vehicleBrand, vehicleModel, comboPackage->getDiscountPercentage());
-void ServiceManagementService::loadObservers()
+	if (serviceBooking == nullptr)
-{
+	{
-    util::loadObservers(config::file::SERVICEMANAGEMENTOBSERVERS, this, m_dataStore);
+		throw std::runtime_error("Failed to create combo package service booking");
-}
+	}
-
+	serviceBookingMap[serviceBooking->getId()] = serviceBooking;
-/*
+	sendNotification(authenticatedUser,
-Function: saveObservers
+		"Combo Package Service Booking succeeded",
-Description: Saves the current observer IDs of the ServiceManagementService
+		"Your service booking for the combo package has been successfully placed with ID " + serviceBooking->getId());
-             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

@@ -1,3 +1,11 @@
+/*
+File: ServiceManagementService.h
+Description: Header file declaring the ServiceManagementService class, which manages
+             services, combo packages, job cards, and service bookings. Inherits from
+             NotificationManagementService to handle notifications.
+Author: Trenser
+Date:19-May-2026
+*/
 #pragma once
 #include <string>
 #include "Map.h"
@@ -14,7 +22,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 +42,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,112 @@
-#include "UserManagementService.h"
+/*
-#include "FileManager.h"
+File: UserManagementService.cpp
+Description: Implementation file containing the method definitions of the
+			 UserManagementService class, including user creation, updates,
+			 and ensuring an admin account exists.
+Author: Trenser
+Date:19-May-2026
+*/
+#include <stdexcept>
 #include "User.h"
-#include "Notification.h"
+#include "Enums.h"
 #include "Config.h"
+#include "UserManagementService.h"
+#include "ServiceManagementService.h"
+#include "PaymentManagementService.h"
+#include "InventoryManagementService.h"
+#include "Factory.h"
 
 /*
-Function: loadUsers
+Function: ensureAdminExists
-Description: Loads users and notifications from persistent storage into the datastore.
+Description: Ensures that at least one admin user exists in the system.
-             Validates that each notification’s recipient exists and attaches the
+			 If no admin is found, creates a default admin user using
-             notification to the corresponding user.
+			 configuration constants.
-Parameters:
+Parameter: None
-    - None
+Return type: void
-Returns:
-    - void
-Throws:
-    - std::runtime_error if a notification recipient user ID is invalid
 */
-void UserManagementService::loadUsers()
+void UserManagementService::ensureAdminExists()
 {
-    util::FileManager<User> userFileManager(config::file::USER_FILE);
+	auto& usersMap = m_dataStore.getUsers();
-    util::FileManager<Notification> notificationFileManager(config::file::NOTIFICATION_FILE);
+	int usersMapSize = usersMap.getSize();
-    auto& users = m_dataStore.getUsers();
+	bool isAdminFound = false;
-    auto usersMap = userFileManager.load();
+	for (int index = 0; index < usersMapSize; index++)
-    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);
+		User* user = usersMap.getValueAt(index);
+		if (user && user->getUserType() == util::UserType::ADMIN)
+		{
+			isAdminFound = true;
+			break;
 		}
-    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);
+	if (!isAdminFound)
-        user->addNotification(notification);
+	{
+		createUser(
+			config::admin::DEFAULT_ADMIN_USERNAME,
+			config::admin::DEFAULT_ADMIN_NAME,
+			config::admin::DEFAULT_ADMIN_PASSWORD,
+			config::admin::DEFAULT_ADMIN_EMAIL,
+			config::admin::DEFAULT_ADMIN_PHONE, 
+			util::UserType::ADMIN);
 	}
 }
 
 /*
-Function: saveUsers
+Function: createUser
-Description: Saves users and their notifications from the datastore to persistent storage.
+Description: Creates a new user with the provided details. Validates that
-             Collects notifications from all users into a single map before saving.
+			 the username is unique, then attaches the user to relevant
-Parameters:
+			 management services (payment, service, inventory).
-    - None
+Parameter: const std::string& username - user’s username
-Returns:
+		   const std::string& name - user’s name
-    - void
+		   const std::string& password - user’s password
+		   const std::string& email - user’s email address
+		   const std::string& phone - user’s phone number
+		   util::UserType type - type of user (ADMIN, CUSTOMER, TECHNICIAN)
+Return type: void
 */
-void UserManagementService::saveUsers()
+void UserManagementService::createUser(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone, util::UserType type)
 {
-    util::FileManager<User> userFileManager(config::file::USER_FILE);
+	InventoryManagementService inventoryManagementService;
-    util::FileManager<Notification> notificationFileManager(config::file::NOTIFICATION_FILE);
+	PaymentManagementService paymentManagementService;
-    auto& users = m_dataStore.getUsers();
+	ServiceManagementService serviceManagementService;
-    util::Map<std::string, Notification*> notifications;
+	auto& usersMap = m_dataStore.getUsers();
-    for (int userIndex = 0; userIndex < users.getSize(); userIndex++)
+	int index = usersMap.findIf(
+		[&](const std::string&, User* user)
 		{
-        User* user = users.getValueAt(userIndex);
+			return user->getUserName() == username;
-        auto& userNotifications = user->getNotifications();
+		}
-        for (int notificationIndex = 0; notificationIndex < userNotifications.getSize(); notificationIndex++)
+	);
+	if (index != -1)
 	{
-            notifications[userNotifications.getKeyAt(notificationIndex)] =
+		throw std::runtime_error("Username already exists");
-                userNotifications.getValueAt(notificationIndex);
 	}
+	User* newUser = Factory::getObject<User>(username, password, name, phone, email, type);
+	usersMap.insert(newUser->getId(), newUser);
+	paymentManagementService.attach(newUser);
+	serviceManagementService.attach(newUser);
+	if (newUser->getUserType() == util::UserType::ADMIN)
+	{
+		inventoryManagementService.attach(newUser);
 	}
-    userFileManager.save(users);
+}
-    notificationFileManager.save(notifications);
+
+/*
+Function: updateUserDetails
+Description: Updates the email and phone details of an existing user.
+			 Throws an exception if the user does not exist.
+Parameter: const std::string& userID - ID of the user to update
+		   const std::string& email - new email address
+		   const std::string& phone - new phone number
+Return type: void
+*/
+void UserManagementService::updateUserDetails(const std::string& userID, const std::string& email, const std::string& phone)
+{
+	auto& usersMap = m_dataStore.getUsers();
+	int index = usersMap.find(userID);
+	if (index == -1)
+	{
+		throw std::runtime_error("User does not exist!");
+	}
+	User* user = usersMap.getValueAt(index);
+	user->setEmail(email);
+	user->setPhone(phone);
 }

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

@@ -1,3 +1,11 @@
+/*
+File: UserManagementService.h
+Description: Header file declaring the UserManagementService class, which manages
+             user creation, updates, retrieval, removal, notifications, and ensures
+             the existence of an admin account.
+Author: Trenser
+Date:19-May-2026
+*/
 #pragma once
 #include <string>
 #include "Map.h"
@@ -13,7 +21,7 @@ private:
     DataStore& m_dataStore;
 public:
     UserManagementService() : m_dataStore(DataStore::getInstance()) {}
-    void createUser(const std::string& username, const std::string& password, const std::string& email, const std::string& phone, util::UserType type);
+    void createUser(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone, util::UserType type);
     void updateUserDetails(const std::string& userID, const std::string& email, const std::string& phone);
     util::Map<std::string, User*> getUsers();
     util::Map<std::string, User*> getUsers(util::UserType type);
@@ -21,6 +29,5 @@ 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 ensureAdminExists();
-    void saveUsers();
 };

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

@@ -1,19 +1,21 @@
+/*
+File: Config.h
+Description: Header file declaring configuration constants for the Vehicle Service System.
+			 Includes default admin account details such as username, name, password,
+			 email, and phone number.
+Author: Trenser
+Date:19-May-2026
+*/
 #pragma once
 
 namespace config
 {
-	namespace file
+	namespace admin
 	{
-		constexpr const char* INVENTORYITEM_FILE = "files/InventoryItem.csv";
+		constexpr const char* DEFAULT_ADMIN_USERNAME = "admin";
-		constexpr const char* USER_FILE = "files/User.csv";
+		constexpr const char* DEFAULT_ADMIN_NAME = "admin";
-		constexpr const char* NOTIFICATION_FILE = "files/Notification.csv";
+		constexpr const char* DEFAULT_ADMIN_PASSWORD = "";
-		constexpr const char* SERVICE_FILE = "files/Service.csv";
+		constexpr const char* DEFAULT_ADMIN_EMAIL = "admin@vss";
-		constexpr const char* COMBOPACKAGE_FILE = "files/ComboPackage.csv";
+		constexpr const char* DEFAULT_ADMIN_PHONE = "0000000000";
-		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 +1,49 @@
 /*
-File: ObserversHelper.h
+File: Utility.h
-Description: Provides utility functions for loading and saving observers
+Description: Header file declaring utility functions used across the system,
-             in the notification management system. Ensures that observer
+             including cost calculation for services and combo packages.
-             IDs are validated against existing users in the datastore
-             before attaching them to the notification service.
 Author: Trenser
-Date: 22-May-2026
+Date:19-May-2026
 */
-
 #pragma once
-#include "NotificationManagementService.h"
+#include "Service.h"
-#include "FileHelper.h"
+#include "InventoryItem.h"
-#include "DataStore.h"
 
-namespace util
+/*
+Function: calculatePartsCost
+Description: Calculates the total cost of parts required for a given service
+             by summing the prices of all associated inventory items.
+Parameter: const Service* service - pointer to the service object
+Return type: double - total cost of required parts
+*/
+inline double calculatePartsCost(const Service* service)
 {
-    /*
+    double cost = 0;
-    Function: loadObservers
+    auto& requiredInventoryItems = service->getRequiredInventoryItems();
-    Description: Loads observer IDs from a file and attaches the corresponding users
+    int requiredInventoryItemsSize = requiredInventoryItems.getSize();
-                 to the notification management service. Validates that each observer ID
+    for (int index = 0; index < requiredInventoryItemsSize; index++)
-                 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);
+        cost += requiredInventoryItems.getValueAt(index)->getPrice();
-        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);
     }
+    return cost;
+}
+
+/*
+Function: calculateComboServiceEstimatedCost
+Description: Calculates the estimated total cost of a combo package by summing
+             the labor and parts costs of all services included in the package.
+Parameter: const ComboPackage* comboPackage - pointer to the combo package object
+Return type: double - estimated total cost of the combo package
+*/
+inline double calculateComboServiceEstimatedCost(const ComboPackage* comboPackage)
+{
+    double cost = 0;
+    auto& services = comboPackage->getServices();
+    int servicesSize = services.getSize();
+    for (int index = 0; index < servicesSize; index++)
+    {
+        const Service* service = services.getValueAt(index);
+        cost += calculatePartsCost(service) + service->getLaborCost();
+    }
+    return cost;
 }

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

@@ -1,21 +1,54 @@
+/*
+File: CustomerMenu.cpp
+Description: Implementation file containing the method definitions of the
+             CustomerMenu class, including menu handling, service selection,
+             combo package booking, profile updates, and password management.
+Author: Trenser
+Date:19-May-2026
+*/
+#include <iomanip>
 #include "CustomerMenu.h"
+#include "Service.h"
+#include "InventoryItem.h"
+#include "ComboPackage.h"
+#include "Service.h"
 #include "InputHelper.h"
 #include "OutputHelper.h"
+#include "Validator.h"
+#include "Vector.h"
+#include "Utility.h"
+#include "Map.h"
 
+/*
+Function: showMenu
+Description: Displays the customer menu and handles user input until logout is selected.
+Parameter: None
+Return type: void
+*/
 void CustomerMenu::showMenu()
 {
-	bool isMenuActive = true;
+    while (true)
-	while (isMenuActive)
     {
         try
         {
             int choice;
             util::clear();
-			std::cout << "" << std::endl;
+            std::cout << "Customer Menu"
+                << "\n1. Select a service"
+                << "\n2. Select a combo package"
+                << "\n3. Update Profile"
+                << "\n4. Change Password"
+                << "\n5. View Service History"
+                << "\n6. Complete Payments"
+                << "\n7. View Invoices"
+                << "\n8. View Notifications"
+                << "\n9. Configure Notifications"
+                << "\n10. Logout"
+                << "\nEnter a choice: ";
             util::read(choice);
             if (!handleOperation(choice))
             {
-				isMenuActive = false;
+                break;
             }
         }
         catch (const std::exception& e)
@@ -26,29 +59,277 @@ void CustomerMenu::showMenu()
     }
 }
 
+/*
+Function: handleOperation
+Description: Executes the corresponding customer operation based on the selected menu choice.
+Parameter: int choice - selected menu option
+Return type: bool - true if menu continues, false if logout
+*/
 bool CustomerMenu::handleOperation(int choice)
 {
+    switch (choice)
+    {
+    case 1:
+        selectService();
+        break;
+    case 2:
+        selectComboPackage();
+        break;
+    case 3:
+        updateDetails();
+        break;
+    case 4:
+        changePassword();
+        break;
+    case 5:
+        viewServiceHistory();
+        break;
+    case 6:
+        completePayments();
+        break;
+    case 7:
+        viewInvoices();
+        break;
+    case 8:
+        viewNotifications();
+        break;
+    case 9:
+        configureNotifications();
+        break;
+    case 10:
+        logout();
         return false;
+    default:
+        std::cout << "Enter a valid choice!" << std::endl;
+        util::pressEnter();
+    }
+    return true;
 }
 
+/*
+Function: logout
+Description: Logs out the currently authenticated customer user.
+Parameter: None
+Return type: void
+*/
 void CustomerMenu::logout()
 {
+	m_controller.logout();
 }
 
+/*
+Function: changePassword
+Description: Allows the customer to change their password after validation.
+Parameter: None
+Return type: void
+*/
 void CustomerMenu::changePassword()
 {
+	std::string newPassword;
+	util::clear();
+	std::cout << "Enter new password: ";
+	util::read(newPassword);
+	m_controller.changePassword(newPassword);
+	if (!util::isPasswordValid(newPassword))
+	{
+		std::cout << "Error: Password is not strong enough!";
+		util::pressEnter();
+		return;
+	}
+	std::cout << "Password changed successfully";
+	util::pressEnter();
 }
 
+/*
+Function: updateDetails
+Description: Allows the customer to update their email and phone number after validation.
+Parameter: None
+Return type: void
+*/
 void CustomerMenu::updateDetails()
 {
+	std::string email, phone;
+	util::clear();
+	std::cout << "Enter new email: ";
+	util::read(email);
+	if (!util::isEmailValid(email))
+	{
+		std::cout << "Error: Email is invalid!";
+		util::pressEnter();
+		return;
+	}
+	std::cout << "Enter new phone: ";
+	util::read(phone);
+	if (!util::isPhoneNumberValid(phone))
+	{
+		std::cout << "Error: Phone number is invalid!";
+		util::pressEnter();
+		return;
+	}
+	m_controller.updateUserDetails(email, phone);
+	std::cout << "Profile details updated successfully";
+	util::pressEnter();
 }
 
+/*
+Function: selectServiceFromServices
+Description: Displays active services and allows the customer to select one by index.
+Parameter: const util::Map<std::string, const Service*>& services - list of services
+Return type: const Service* - selected service
+*/
+static const Service* selectServiceFromServices(const util::Map<std::string, const Service*>& services)
+{
+    util::Map<int, const Service*> activeServicesMap;
+    int currentIndex = 1;
+    int userInputIndex;
+    std::cout << std::left
+        << std::setw(10) << "Index"
+        << std::setw(15) << "Service ID"
+        << std::setw(25) << "Service Name"
+        << std::setw(15) << "Estimated Cost"
+        << std::endl;
+    for (int index = 0; index < services.getSize(); index++)
+    {
+        const Service* currentService = services.getValueAt(index);
+        if (currentService->getState() != util::State::ACTIVE)
+        {
+            continue;
+        }
+        activeServicesMap.insert(currentIndex, currentService);
+        double partsCost = calculatePartsCost(currentService);
+        std::cout << std::left
+            << std::setw(10) << currentIndex
+            << std::setw(15) << currentService->getId()
+            << std::setw(25) << currentService->getName()
+            << std::setw(15) << (currentService->getLaborCost() + partsCost)
+            << std::endl;
+        currentIndex++;
+    }
+    if (activeServicesMap.getSize() == 0)
+    {
+        std::cout << "No active services available." << std::endl;
+        return nullptr;
+    }
+    std::cout << "Enter service index: ";
+    util::read(userInputIndex);
+    if (activeServicesMap.find(userInputIndex) == -1)
+    {
+        std::cout << "Invalid service index." << std::endl;
+        return nullptr;
+    }
+    return activeServicesMap[userInputIndex];
+}
+
+/*
+Function: selectService
+Description: Allows the customer to select a service, provide vehicle details,
+             and book the service through the controller.
+Parameter: None
+Return type: void
+*/
 void CustomerMenu::selectService()
 {
+    std::string vehicleNumber, vehicleBrand, vehicleModel;
+	auto services = m_controller.getServices();
+    util::Vector<std::string> selectedServices;
+    util::clear();
+    const Service* selectedService = selectServiceFromServices(services);
+    if (selectedService == nullptr)
+    {
+        std::cout << "Failed to book service!";
+        util::pressEnter();
+        return;
+    }
+    selectedServices.push_back(selectedService->getId());
+    util::clear();
+    std::cout << "Enter vehicle number: ";
+    util::read(vehicleNumber);
+    std::cout << "Enter vehicle brand: ";
+    util::read(vehicleBrand);
+    std::cout << "Enter vehicle model: ";
+    util::read(vehicleModel);
+    m_controller.purchaseService(selectedServices, vehicleNumber, vehicleBrand, vehicleModel);
+    std::cout << "Service has been booked successfully";
+    util::pressEnter();
 }
 
+/*
+Function: selectComboPackageFromPackages
+Description: Displays active combo packages and allows the customer to select one by index.
+Parameter: const util::Map<std::string, const ComboPackage*>& comboPackages - list of combo packages
+Return type: const ComboPackage* - selected combo package
+*/
+static const ComboPackage* selectComboPackageFromPackages(const util::Map<std::string, const ComboPackage*>& comboPackages)
+{
+    util::Map<int, const ComboPackage*> activeComboPackages;
+    int currentIndex = 1;
+    int userInputIndex;
+    std::cout << std::left
+        << std::setw(10) << "Index"
+        << std::setw(15) << "Combo Package ID"
+        << std::setw(15) << "Combo Package Name"
+        << std::setw(15) << "Estimate Cost"
+        << std::endl;
+    for (int index = 0; index < comboPackages.getSize(); index++)
+    {
+        const ComboPackage* currentComboPackage = comboPackages.getValueAt(index);
+        if (currentComboPackage->getState() != util::State::ACTIVE)
+        {
+            continue;
+        }
+        activeComboPackages.insert(currentIndex, currentComboPackage);
+        std::cout << std::left
+            << std::setw(10) << currentIndex
+            << std::setw(15) << currentComboPackage->getId()
+            << std::setw(25) << currentComboPackage->getPackageName()
+            << std::setw(15) << calculateComboServiceEstimatedCost(currentComboPackage)
+            << std::endl;
+        currentIndex++;
+    }
+    if (activeComboPackages.getSize() == 0)
+    {
+        std::cout << "No active combo packages available." << std::endl;
+        return nullptr;
+    }
+    std::cout << "Enter combo package index: ";
+    util::read(userInputIndex);
+    if (activeComboPackages.find(userInputIndex) == -1)
+    {
+        std::cout << "Invalid combo package index." << std::endl;
+        return nullptr;
+    }
+    return activeComboPackages[userInputIndex];
+}
+
+/*
+Function: selectComboPackage
+Description: Allows the customer to select a combo package, provide vehicle details,
+             and book the package through the controller.
+Parameter: None
+Return type: void
+*/
 void CustomerMenu::selectComboPackage()
 {
+    std::string vehicleNumber, vehicleBrand, vehicleModel;
+    auto comboPackages = m_controller.getComboPackages();
+    util::clear();
+    const ComboPackage* selectedComboPackage = selectComboPackageFromPackages(comboPackages);
+    if (selectedComboPackage == nullptr)
+    {
+        std::cout << "Failed to book combo package!";
+        util::pressEnter();
+        return;
+    }
+    util::clear();
+    std::cout << "Enter vehicle number: ";
+    util::read(vehicleNumber);
+    std::cout << "Enter vehicle brand: ";
+    util::read(vehicleBrand);
+    std::cout << "Enter vehicle model: ";
+    util::read(vehicleModel);
+    m_controller.purchaseComboPackage(selectedComboPackage->getId(), vehicleNumber, vehicleBrand, vehicleModel);
+    std::cout << "Combo Package has been booked successfully";
+    util::pressEnter();
 }
 
 void CustomerMenu::viewServiceHistory()

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

@@ -1,3 +1,12 @@
+/*
+File: CustomerMenu.h
+Description: Header file declaring the CustomerMenu class, which provides
+             customer operations such as selecting services, booking combo
+             packages, updating profile details, managing payments, viewing
+             invoices, and configuring notifications.
+Author: Trenser
+Date:19-May-2026
+*/
 #pragma once
 #include "Controller.h"
 

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

@@ -0,0 +1,62 @@
+/*
+File: MenuHelper.h
+Description: Header file declaring the MenuHelper class, which provides
+             utility functions for menu-driven operations such as
+             notification selection and display.
+Author: Trenser
+Date:19-May-2026
+*/
+#pragma once
+#include <string>
+#include <iomanip>
+#include "Notification.h"
+#include "Map.h"
+#include "InputHelper.h"
+#include "OutputHelper.h"
+
+/*
+Function: selectNotification
+Description: Displays a list of notifications with index, ID, title, and timestamp.
+             Allows the user to select a notification by index. Returns the selected
+             notification or nullptr if the selection is invalid.
+Parameter: const util::Vector<const Notification*>& notifications - list of notifications
+Return type: const Notification* - pointer to the selected notification
+*/
+inline const Notification* selectNotification(const util::Vector<const Notification*>& notifications)
+{
+    if (notifications.getSize() == 0)
+    {
+        std::cout << "No notifications available." << std::endl;
+        return nullptr;
+    }
+    std::cout << std::left
+        << std::setw(6) << "Index"
+        << std::setw(15) << "ID"
+        << std::setw(30) << "Title"
+        << std::setw(25) << "Timestamp"
+        << std::endl;
+    int currentIndex = 1;
+    for (int iterator = 0; iterator < notifications.getSize(); iterator++)
+    {
+        const Notification* currentNotification = notifications[iterator];
+        if (currentNotification)
+        {
+            std::cout << std::left
+                << std::setw(6) << currentIndex
+                << std::setw(15) << currentNotification->getId()
+                << std::setw(30) << currentNotification->getTitle()
+                << std::setw(25) << currentNotification->getCreatedAt().toString()
+                << std::endl;
+            currentIndex++;
+        }
+    }
+    int selectedIndex;
+    std::cout << "Select notification: ";
+    util::read(selectedIndex);
+    if (selectedIndex < 1 || selectedIndex > notifications.getSize())
+    {
+        std::cout << "Invalid selection." << std::endl;
+        return nullptr;
+    }
+    return notifications[selectedIndex - 1];
+}

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

@@ -1,10 +1,27 @@
+/*
+File: UserInterface.cpp
+Description: Implementation file containing the method definitions of the
+			 UserInterface class, including system run loop, login handling,
+			 and customer registration logic.
+Author: Trenser
+Date:19-May-2026
+*/
 #include "UserInterface.h"
 #include "InputHelper.h"
 #include "OutputHelper.h"
+#include "Enums.h"
+#include "User.h"
+#include "Validator.h"
 
+/*
+Function: run
+Description: Runs the main system loop, displaying the initial menu for login,
+			 customer registration, or exit. Handles exceptions gracefully.
+Parameter: None
+Return type: void
+*/
 void UserInterface::run()
 {
-	m_controller.loadSystemData();
 	bool isMenuActive = true;
 	while (isMenuActive)
 	{
@@ -25,9 +42,14 @@ void UserInterface::run()
 			util::pressEnter();
 		}
 	}
-	m_controller.saveSystemData();
 }
 
+/*
+Function: handleOperation
+Description: Executes the corresponding system operation based on the selected menu choice.
+Parameter: int choice - selected menu option
+Return type: bool - true if menu continues, false if exit
+*/
 bool UserInterface::handleOperation(int choice)
 {
 	switch (choice)
@@ -48,12 +70,90 @@ bool UserInterface::handleOperation(int choice)
 	return true;
 }
 
+/*
+Function: login
+Description: Handles user login by validating credentials. Based on the authenticated
+			 user type, navigates to the appropriate menu (Admin, Technician, Customer).
+Parameter: None
+Return type: void
+*/
 void UserInterface::login()
 {
-
+	std::string username, password;
+	util::clear();
+	std::cout << "Enter username: ";
+	util::read(username);
+	std::cout << "Enter password: ";
+	util::read(password);
+	if (m_controller.login(username, password))
+	{
+		const User* authenticatedUser = m_controller.getAuthenticatedUser();
+		if (authenticatedUser != nullptr)
+		{
+			switch (authenticatedUser->getUserType())
+			{
+			case util::UserType::ADMIN:
+				m_adminMenu.showMenu();
+				break;
+			case util::UserType::TECHNICIAN:
+				m_technicianMenu.showMenu();
+				break;
+			case util::UserType::CUSTOMER:
+				m_customerMenu.showMenu();
+				break;
+			default:
+				std::cout << "\nError: Unknown user type";
+				break;
+			}
+		}
+	}
+	else
+	{
+		std::cout << "\nError: Invalid Username or Password";
+	}
 }
 
+/*
+Function: registerCustomer
+Description: Registers a new customer by collecting and validating details such as
+			 username, name, email, password, and phone number. Delegates creation
+			 to the controller.
+Parameter: None
+Return type: void
+*/
 void UserInterface::registerCustomer()
 {
-
+	std::string username, name, email, phone, password;
+	util::clear();
+	std::cout << "Enter username: ";
+	util::read(username);
+	std::cout << "Enter name: ";
+	util::read(name);
+	std::cout << "Enter email: ";
+	util::read(email);
+	if (!util::isEmailValid(email))
+	{
+		std::cout << "Error: Email is invalid!";
+		util::pressEnter();
+		return;
+	}
+	std::cout << "Enter password: ";
+	util::read(password);
+	if (!util::isPasswordValid(password))
+	{
+		std::cout << "Error: Password is invalid!";
+		util::pressEnter();
+		return;
+	}
+	std::cout << "Enter phone: ";
+	util::read(phone);
+	if (!util::isPhoneNumberValid(phone))
+	{
+		std::cout << "Error: Phone number is invalid!";
+		util::pressEnter();
+		return;
+	}
+	m_controller.createCustomer(username, name, password, email, phone);
+	std::cout << "Registration is successful";
+	util::pressEnter();
 }

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

@@ -1,3 +1,12 @@
+/*
+File: UserInterface.h
+Description: Header file declaring the UserInterface class, which provides
+             the main entry point for the Vehicle Service System. Handles
+             login, customer registration, and menu navigation for different
+             user roles (Admin, Technician, Customer).
+Author: Trenser
+Date:19-May-2026
+*/
 #pragma once
 #include "Controller.h"
 #include "AdminMenu.h"