Add documentation headers across system modules

<UserStory> SER005: Update Service Status </UserStory>

<Changes>
    1. Integrated Controller with ServiceManagementService to support job completion workflow.
    2. Implemented ServiceManagementService::completeJob with validation for technician assignment, job existence, and status transition.
    3. Enhanced TechnicianMenu with job selection helper to display assigned jobs, allow index-based selection, and handle invalid choices.
    4. Updated TechnicianMenu::completeJob to mark job as completed via Controller and provide user feedback.
    5. Added logic to check if all jobs in a booking are completed, triggering invoice generation and customer notification.
</Changes>

<Test>

 Acceptance Criteria:
 1. Status updates are visible to customers immediately after technician marks job as completed.

 Precondition:
  1. Technician is logged into the system.
  2. At least one active job card is assigned to the technician.
  3. Datastore contains valid service bookings linked to jobs.

 Steps:
  1. Navigate to Technician menu and choose "Complete Job".
    - Verify that the system lists active jobs with index-based selection.
  2. Select a job card by index.
    - Verify that the job status changes from STARTED to COMPLETED.
  3. Check customer view.
    - Verify that the updated status is reflected in the customer’s booking history.
  4. If all jobs in the booking are completed:
    - Verify that an invoice is generated and a notification is sent to the customer.
</Test>

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

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem.cpp

@@ -1,22 +1,5 @@
-/*
-File: Trenser.VehicleServiceSystem.cpp
-Description: Entry point for the Vehicle Service Management System.
-			 Initializes the UserInterface and starts the application loop.
-Author: Trenser
-Date: 19-May-2026
-*/
-
 #include "UserInterface.h"
 
-/*
-Function: main
-Description: The main entry point of the application.
-			 Creates a UserInterface object and invokes the run method to start the system.
-Parameters:
-	- None
-Returns:
-	- int: Exit status code (0 for successful execution).
-*/
 int main()
 {
 	UserInterface userInterface;

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

@@ -171,21 +171,15 @@
     <ClInclude Include="services\PaymentManagementService.h" />
     <ClInclude Include="services\ServiceManagementService.h" />
     <ClInclude Include="services\UserManagementService.h" />
-    <ClInclude Include="utilities\Config.h" />
     <ClInclude Include="utilities\Enums.h" />
-    <ClInclude Include="utilities\FileHelper.h" />
-    <ClInclude Include="utilities\FileManager.h" />
     <ClInclude Include="utilities\InputHelper.h" />
     <ClInclude Include="utilities\Map.h" />
     <ClInclude Include="utilities\OutputHelper.h" />
-    <ClInclude Include="utilities\StringHelper.h" />
     <ClInclude Include="utilities\Timestamp.h" />
-    <ClInclude Include="utilities\Utility.h" />
     <ClInclude Include="utilities\Validator.h" />
     <ClInclude Include="utilities\Vector.h" />
     <ClInclude Include="views\AdminMenu.h" />
     <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,23 +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>
-    <ClInclude Include="views\MenuHelper.h">
-      <Filter>Header Files\Views</Filter>
-    </ClInclude>
   </ItemGroup>
 </Project>

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

@@ -1,101 +1,56 @@
-/*
-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 "InventoryItem.h"
-#include "User.h"
+#include "Service.h"
+#include "ServiceBooking.h"
+#include "JobCard.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 m_authenticationManagementService.login(username, password);
+    return false;
 }
 
-/*
-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 m_authenticationManagementService.getAuthenticatedUser();
+    return nullptr;
 }
 
-void Controller::createTechnician(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone)
+void Controller::createTechnician(const std::string& username, const std::string& password, const std::string& email, const std::string& phone)
+{
+}
+
+void Controller::updateUserDetails(const std::string& email, const std::string& phone)
 {
 }
 
 /*
-Function: updateUserDetails
+Function: getServices
-Description: Updates the email and phone details of the currently authenticated user.
+Description: Retrieves all available services in read-only form.
-Parameter: const std::string& email - new email address
+Parameters:
-           const std::string& phone - new phone number
+    - None
-Return type: void
+Returns:
+    - util::Map<std::string, const Service*> containing all services
 */
-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()
 {
-    return util::Map<std::string, const Service*>();
+    util::Map<std::string, Service*> currentServices = m_serviceManagementService.getServices();
+    util::Map<std::string, const Service*> readOnlyServices;
+    for (int iterator = 0; iterator < currentServices.getSize(); iterator++)
+    {
+        readOnlyServices.insert(currentServices.getValueAt(iterator)->getId(), currentServices.getValueAt(iterator));
+    }
+    return readOnlyServices;
 }
 
 util::Map<std::string, const ComboPackage*> Controller::getComboPackages()
@@ -103,37 +58,18 @@ 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()
 {
-    return util::Map<std::string, const InventoryItem*>();
+    util::Map<std::string, const InventoryItem*> dummyMap;
+    return dummyMap;
 }
 
 const InventoryItem* Controller::getInventoryItem(const std::string& inventoryItemID)
@@ -149,14 +85,42 @@ void Controller::removeInventoryItem(const std::string& inventoryItemID)
 {
 }
 
+/*
+Function: getServiceBookings
+Description: Retrieves all service bookings in read-only form.
+Parameters:
+    - None
+Returns:
+    - util::Map<std::string, const ServiceBooking*> containing service bookings
+*/
 util::Map<std::string, const ServiceBooking*> Controller::getServiceBookings()
 {
-    return util::Map<std::string, const ServiceBooking*>();
+    auto serviceBookings = m_serviceManagementService.getServiceBookings();
+    util::Map<std::string, const ServiceBooking*> readOnlyServiceBookings;
+    for (int iterator = 0; iterator < serviceBookings.getSize(); iterator++)
+    {
+        readOnlyServiceBookings.insert(serviceBookings.getKeyAt(iterator), serviceBookings.getValueAt(iterator));
+    }
+    return readOnlyServiceBookings;
 }
 
+/*
+Function: getServiceBookingsByUser
+Description: Retrieves all service bookings for a specific user.
+Parameters:
+    - userID: std::string, the user ID
+Returns:
+    - util::Map<std::string, const ServiceBooking*> containing bookings for the user
+*/
 util::Map<std::string, const ServiceBooking*> Controller::getServiceBookingsByUser(const std::string userID)
 {
-    return util::Map<std::string, const ServiceBooking*>();
+    util::Map<std::string, const ServiceBooking*> readOnlyServiceBookingsByUserMap;
+    util::Map<std::string, ServiceBooking*> currentServiceBookingsByUser = m_serviceManagementService.getServiceBookings(userID);
+    for (int iterator = 0; iterator < currentServiceBookingsByUser.getSize(); iterator++)
+    {
+        readOnlyServiceBookingsByUserMap.insert(currentServiceBookingsByUser.getValueAt(iterator)->getId(), currentServiceBookingsByUser.getValueAt(iterator));
+    }
+    return readOnlyServiceBookingsByUserMap;
 }
 
 util::Map<std::string, const User*> Controller::getUsers()
@@ -164,30 +128,100 @@ util::Map<std::string, const User*> Controller::getUsers()
     return util::Map<std::string, const User*>();
 }
 
+/*
+Function: getUsers
+Description: Retrieves users filtered by user type.
+Parameters:
+    - userType: util::UserType, type of user (CUSTOMER, TECHNICIAN, ADMIN)
+Returns:
+    - util::Map<std::string, const User*> containing users of the specified type
+*/
 util::Map<std::string, const User*> Controller::getUsers(util::UserType userType)
 {
-    return util::Map<std::string, const User*>();
+    auto userMap = m_userManagementService.getUsers(userType);
+    util::Map<std::string, const User*> readOnlyUserMap;
+    for (int iterator = 0; iterator < userMap.getSize(); iterator++)
+    {
+        readOnlyUserMap.insert(userMap.getKeyAt(iterator), userMap.getValueAt(iterator));
+    }
+    return readOnlyUserMap;
 }
 
+/*
+Function: createJobCard
+Description: Creates a job card for a service booking assigned to a technician.
+Parameters:
+    - bookingID: std::string, ID of the service booking
+    - technicianID: std::string, ID of the technician
+    - serviceID: std::string, ID of the service
+Returns:
+    - void
+*/
 void Controller::createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID)
 {
+    m_serviceManagementService.createJobCard(bookingID, technicianID, serviceID);
 }
 
+/*
+Function: createService
+Description: Creates a new service with associated inventory items and labor cost.
+Parameters:
+    - name: std::string, name of the service
+    - inventoryItemIDs: Vector of inventory item IDs
+    - laborCost: double, labor cost
+Returns:
+    - void
+*/
 void Controller::createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost)
 {
+    m_serviceManagementService.createService(name, inventoryItemIDs, laborCost);
 }
 
+/*
+Function: removeService
+Description: Removes a service from the system by ID.
+Parameters:
+    - serviceID: std::string, ID of the service
+Returns:
+    - void
+*/
 void Controller::removeService(const std::string& serviceID)
 {
+    m_serviceManagementService.removeService(serviceID);
 }
 
+/*
+Function: getJobCardsByUser
+Description: Retrieves job cards assigned to the authenticated technician.
+Parameters:
+    - None
+Returns:
+    - util::Map<std::string, const JobCard*> containing job cards
+*/
 util::Map<std::string, const JobCard*> Controller::getJobCardsByUser()
 {
-    return util::Map<std::string, const JobCard*>();
+    const User* currentUser = getAuthenticatedUser();
+    auto jobCardsAssignedToTechnician = m_serviceManagementService.getJobCards(currentUser->getId());
+    util::Map<std::string, const JobCard*> readOnlyJobCardMap;
+    for (int iterator = 0; iterator < jobCardsAssignedToTechnician.getSize(); iterator++)
+    {
+        JobCard* currentJobCard = jobCardsAssignedToTechnician.getValueAt(iterator);
+        readOnlyJobCardMap.insert(currentJobCard->getId(), currentJobCard);
+    }
+    return readOnlyJobCardMap;
 }
 
+/*
+Function: completeJob
+Description: Marks a job card as completed.
+Parameters:
+    - jobID: std::string, ID of the job card
+Returns:
+    - void
+*/
 void Controller::completeJob(const std::string& jobID)
 {
+    m_serviceManagementService.completeJob(jobID);
 }
 
 void Controller::removeUser(const std::string& userID)
@@ -211,142 +245,20 @@ void Controller::completePayment(const std::string& invoiceID, util::PaymentMode
 {
 }
 
-/*
-Function: getNotifications
-Description: Retrieves all notifications for the currently authenticated user.
-             Converts them into a read-only vector before returning.
-Parameters: None
-Return type: util::Vector<const Notification*>
-*/
 util::Vector<const Notification*> Controller::getNotifications()
 {
-    const User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
+    return util::Vector<const Notification*>();
-    if (!authenticatedUser)
-    {
-        throw std::runtime_error("No user is currently logged in!");
-    }
-    auto notifications = m_userManagementService.getUserNotifications(authenticatedUser->getId());
-    int numberOfNotifications = notifications.getSize();
-    util::Vector<const Notification*> readOnlyNotifications;
-    for (int index = 0; index < numberOfNotifications; index++)
-    {
-        readOnlyNotifications.push_back(notifications[index]);
-    }
-    return readOnlyNotifications;
 }
 
-/*
-Function: deleteNotification
-Description: Deletes a specific notification for the currently authenticated user.
-Parameters:
-    - notificationID: std::string, the unique identifier of the notification
-Return type: void
-*/
 void Controller::deleteNotification(const std::string& notificationID)
 {
-    const User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
-    if (!authenticatedUser)
-    {
-        throw std::runtime_error("No user is currently logged in!");
-    }
-    m_userManagementService.deleteNotification(notificationID, authenticatedUser->getId());
 }
 
-/*
+void Controller::configureNotifications(const std::string& userID, bool paymentNotifications, bool serviceNotifications)
-Function: configureNotifications
-Description: Configures notification preferences for the authenticated user.
-             Attaches or detaches the user from payment and service notifications.
-Parameters:
-    - paymentNotifications: bool, enable/disable payment notifications
-    - serviceNotifications: bool, enable/disable service notifications
-Return type: void
-*/
-void Controller::configureNotifications(bool paymentNotifications, bool serviceNotifications)
 {
-    User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
-    if (authenticatedUser)
-    {
-        if (paymentNotifications)
-        {
-            m_paymentManagementService.attach(authenticatedUser);
-        }
-        else
-        {
-            m_paymentManagementService.detach(authenticatedUser);
-        }
-        if (serviceNotifications)
-        {
-            m_serviceManagementService.attach(authenticatedUser);
-        }
-        else
-        {
-            m_serviceManagementService.detach(authenticatedUser);
-        }
-    }
-    else
-    {
-        throw std::runtime_error("No user is currently logged in!");
-    }
 }
 
-/*
-Function: loadSystemData
-Description: Loads all system data from persistent storage into memory.
-             Invokes the respective management services to load users, inventory items, services,
-             combo packages, service bookings, job cards, invoices, and observers.
-Parameters:
-    - None
-Returns:
-    - void
-*/
-void Controller::loadSystemData()
-{
-    m_userManagementService.loadUsers();
-    m_inventoryManagementService.loadInventoryItems();
-    m_serviceManagementService.loadServices();
-    m_serviceManagementService.loadComboPackages();
-    m_serviceManagementService.loadServiceBookings();
-    m_serviceManagementService.loadJobCards();
-    m_paymentManagementService.loadInvoices();
-    m_serviceManagementService.loadObservers();
-    m_paymentManagementService.loadObservers();
-    m_inventoryManagementService.loadObservers();
-}
-
-/*
-Function: saveSystemData
-Description: Saves all system data from memory back to persistent storage.
-             Invokes the respective management services to save users, inventory items, services,
-             combo packages, service bookings, job cards, invoices, and observers.
-Parameters:
-    - None
-Returns:
-    - void
-*/
-void Controller::saveSystemData()
-{
-    m_userManagementService.saveUsers();
-    m_inventoryManagementService.saveInventoryItems();
-    m_serviceManagementService.saveServices();
-    m_serviceManagementService.saveComboPackages();
-    m_serviceManagementService.saveServiceBookings();
-    m_serviceManagementService.saveJobCards();
-    m_paymentManagementService.saveInvoices();
-    m_serviceManagementService.saveObservers();
-    m_paymentManagementService.saveObservers();
-    m_inventoryManagementService.saveObservers();
-}
-
-/*
-Function: runSystemChecks
-Description: Runs system checks to ensure critical configurations, such as verifying admin existence.
-Parameter: None
-Return type: void
-*/
 void Controller::runSystemChecks()
 {
-    m_userManagementService.ensureAdminExists();
-    m_inventoryManagementService.sendLowStockAlerts();
-    m_paymentManagementService.sendPaymentReminders();
 }
 

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

@@ -1,24 +1,10 @@
-/*
-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 <string>
-#include "AuthenticationManagementService.h"
-#include "Enums.h"
-#include "InventoryManagementService.h"
 #include "Map.h"
-#include "PaymentManagementService.h"
+#include <string>
+#include "Enums.h"
 #include "ServiceManagementService.h"
 #include "UserManagementService.h"
 #include "InventoryManagementService.h"
-#include "UserManagementService.h"
-#include "ServiceManagementService.h"
-#include "PaymentManagementService.h"
 
 class Service;
 class ComboPackage;
@@ -32,18 +18,15 @@ class Notification;
 class Controller
 {
 private:
-    AuthenticationManagementService m_authenticationManagementService;
-    UserManagementService m_userManagementService;
     ServiceManagementService m_serviceManagementService;
-    InventoryManagementService m_inventoryManagementService;
+    UserManagementService m_userManagementService;
-    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& name, const std::string& password, const std::string& email, const std::string& phone);
+    void createCustomer(const std::string& username, const std::string& password, const std::string& email, const std::string& phone);
     const User* getAuthenticatedUser();
-    void createTechnician(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone);
+    void createTechnician(const std::string& username, const std::string& password, const std::string& email, const std::string& phone);
     void updateUserDetails(const std::string& email, const std::string& phone);
     util::Map<std::string, const Service*> getServices();
     util::Map<std::string, const ComboPackage*> getComboPackages();
@@ -69,8 +52,6 @@ public:
     void completePayment(const std::string& invoiceID, util::PaymentMode paymentMode);
     util::Vector<const Notification*> getNotifications();
     void deleteNotification(const std::string& notificationID);
-    void configureNotifications(bool paymentNotifications, bool serviceNotifications);
+    void configureNotifications(const std::string& userID, bool paymentNotifications, bool serviceNotifications);
-    void loadSystemData();
-    void saveSystemData();
     void runSystemChecks();
 };

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

@@ -1,10 +1,3 @@
-/*
-File: Observer.h
-Description: Declares the Observer interface for handling notifications in the Vehicle Service Management System.
-Author: Trenser
-Date: 19-May-2026
-*/
-
 #pragma once
 
 class Notification;
@@ -13,5 +6,5 @@ class Observer
 {
 public:
     virtual ~Observer() = default;
-    virtual void addNotification(Notification* notification) = 0;
+    virtual void update(Notification* notification) = 0;
 };

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

@@ -1,14 +1,6 @@
-/*
-File: Subject.h
-Description: Declares the Subject interface for managing user attachments and detachments in the Observer design pattern within the Vehicle Service Management System.
-Author: Trenser
-Date: 19-May-2026
-*/
-
 #pragma once
 #include <string>
 #include "Map.h"
-#include "Vector.h"
 
 class User;
 class Notification;

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

@@ -1,128 +1,46 @@
-/*
-File: DataStore.cpp
-Description: Implements the DataStore class which provides a centralized singleton repository
-             for managing system data in the Vehicle Service Management System.
-             Includes accessors for users, services, combo packages, service bookings,
-             job cards, inventory items, invoices, and payments.
-Author: Trenser
-Date: 19-May-2026
-*/
-
 #include "DataStore.h"
 
-/*
-Function: getInstance
-Description: Provides a singleton instance of the DataStore class.
-Parameters:
-    - None
-Returns:
-    - Reference to the single DataStore instance.
-*/
 DataStore& DataStore::getInstance()
 {
     static DataStore dataStore;
     return dataStore;
 }
 
-/*
-Function: getUsers
-Description: Retrieves the internal map of users.
-Parameters:
-    - None
-Returns:
-    - Reference to util::Map<std::string, User*> containing all users.
-*/
 util::Map<std::string, User*>& DataStore::getUsers()
 {
     return m_users;
 }
 
-/*
-Function: getServices
-Description: Retrieves the internal map of services.
-Parameters:
-    - None
-Returns:
-    - Reference to util::Map<std::string, Service*> containing all services.
-*/
 util::Map<std::string, Service*>& DataStore::getServices()
 {
     return m_services;
 }
 
-/*
-Function: getComboPackages
-Description: Retrieves the internal map of combo packages.
-Parameters:
-    - None
-Returns:
-    - Reference to util::Map<std::string, ComboPackage*> containing all combo packages.
-*/
 util::Map<std::string, ComboPackage*>& DataStore::getComboPackages()
 {
     return m_comboPackages;
 }
 
-/*
-Function: getServiceBookings
-Description: Retrieves the internal map of service bookings.
-Parameters:
-    - None
-Returns:
-    - Reference to util::Map<std::string, ServiceBooking*> containing all service bookings.
-*/
 util::Map<std::string, ServiceBooking*>& DataStore::getServiceBookings()
 {
     return m_serviceBookings;
 }
 
-/*
-Function: getJobCards
-Description: Retrieves the internal map of job cards.
-Parameters:
-    - None
-Returns:
-    - Reference to util::Map<std::string, JobCard*> containing all job cards.
-*/
 util::Map<std::string, JobCard*>& DataStore::getJobCards()
 {
     return m_jobCards;
 }
 
-/*
-Function: getInventoryItems
-Description: Retrieves the internal map of inventory items.
-Parameters:
-    - None
-Returns:
-    - Reference to util::Map<std::string, InventoryItem*> containing all inventory items.
-*/
 util::Map<std::string, InventoryItem*>& DataStore::getInventoryItems()
 {
     return m_inventoryItems;
 }
 
-/*
-Function: getInvoices
-Description: Retrieves the internal map of invoices.
-Parameters:
-    - None
-Returns:
-    - Reference to util::Map<std::string, Invoice*> containing all invoices.
-*/
 util::Map<std::string, Invoice*>& DataStore::getInvoices()
 {
     return m_invoices;
 }
 
-/*
-Function: getPayments
-Description: Retrieves the internal map of payments.
-Parameters:
-    - None
-Returns:
-    - Reference to util::Map<std::string, Payment*> containing all payments.
-*/
 util::Map<std::string, Payment*>& DataStore::getPayments()
 {
     return m_payments;

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

@@ -1,11 +1,5 @@
-/*
-File: DataStore.h
-Description: Declares the DataStore singleton class responsible for managing collections of users, services, combo packages, service bookings, job cards, inventory items, invoices, and payments in the Vehicle Service Management System.
-Author: Trenser
-Date: 19-May-2026
-*/
-
 #pragma once
+
 #include <string>
 #include "Map.h"
 

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

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

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

@@ -1,341 +1,65 @@
-/*
-File: ComboPackage.cpp
-Description: Implements the ComboPackage class which represents a bundled set of services in the Vehicle Service Management System.
-             Provides constructors, accessors, and mutators for package details such as ID, name, discount percentage, state,
-             and associated services.
-Author: Trenser
-Date: 19-May-2026
-*/
-
-#include <sstream>
-#include <stdexcept>
 #include "ComboPackage.h"
-#include "Service.h"
-#include "Factory.h"
-#include "StringHelper.h"
 
 int ComboPackage::m_uid = 0;
 
-/*
-Function: ComboPackage
-Description: Default constructor that initializes a new combo package with a unique ID,
-             active state, and zero discount percentage.
-Parameters:
-    - None
-Returns:
-    - A new ComboPackage object.
-*/
 ComboPackage::ComboPackage()
     : m_id("CMP" + std::to_string(++m_uid)),
     m_status(util::State::ACTIVE),
     m_discountPercentage(0.0) {}
 
-/*
-Function: ComboPackage
-Description: Parameterized constructor that initializes a new combo package with a unique ID,
-             specified package name, discount percentage, active state, and associated services.
-Parameters:
-    - packageName: Name of the combo package.
-    - discountPercentage: Discount percentage applied to the package.
-    - services: Map of services included in the package.
-Returns:
-    - A new ComboPackage object.
-*/
 ComboPackage::ComboPackage(const std::string& packageName, double discountPercentage, const util::Map<std::string, Service*>& services)
     : m_id("CMP" + std::to_string(++m_uid)),
     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;
-    }
-}
-
-/*
-Function: getId
-Description: Retrieves the unique ID of the combo package.
-Parameters:
-    - None
-Returns:
-    - const std::string& representing the package ID.
-*/
 const std::string& ComboPackage::getId() const
 {
     return m_id;
 }
 
-/*
-Function: getPackageName
-Description: Retrieves the name of the combo package.
-Parameters:
-    - None
-Returns:
-    - const std::string& representing the package name.
-*/
 const std::string& ComboPackage::getPackageName() const
 {
     return m_packageName;
 }
 
-/*
-Function: getDiscountPercentage
-Description: Retrieves the discount percentage applied to the combo package.
-Parameters:
-    - None
-Returns:
-    - double representing the discount percentage.
-*/
 double ComboPackage::getDiscountPercentage() const
 {
     return m_discountPercentage;
 }
 
-/*
-Function: getState
-Description: Retrieves the current state (ACTIVE/INACTIVE) of the combo package.
-Parameters:
-    - None
-Returns:
-    - util::State representing the package state.
-*/
 util::State ComboPackage::getState() const
 {
     return m_status;
 }
 
-const util::Vector<std::string>& ComboPackage::getServiceIDs() const
-{
-    return m_serviceIDs;
-}
-
-/*
-Function: getServices
-Description: Retrieves the map of services included in the combo package.
-Parameters:
-    - None
-Returns:
-    - const util::Map<std::string, Service*>& representing the services.
-*/
 const util::Map<std::string, Service*>& ComboPackage::getServices() const
 {
     return m_services;
 }
 
-/*
-Function: setId
-Description: Sets the unique ID of the combo package.
-Parameters:
-    - id: New ID string.
-Returns:
-    - void
-*/
 void ComboPackage::setId(const std::string& id)
 {
     m_id = id;
 }
 
-/*
-Function: setPackageName
-Description: Sets the name of the combo package.
-Parameters:
-    - packageName: New package name string.
-Returns:
-    - void
-*/
 void ComboPackage::setPackageName(const std::string& packageName)
 {
     m_packageName = packageName;
 }
 
-/*
-Function: setDiscountPercentage
-Description: Sets the discount percentage for the combo package.
-Parameters:
-    - discountPercentage: New discount percentage value.
-Returns:
-    - void
-*/
 void ComboPackage::setDiscountPercentage(double discountPercentage)
 {
     m_discountPercentage = discountPercentage;
 }
 
-/*
-Function: setServices
-Description: Sets the services included in the combo package.
-Parameters:
-    - services: Map of services to be associated with the package.
-Returns:
-    - void
-*/
 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());
-    }
 }
 
-/*
-Function: setState
-Description: Sets the state (ACTIVE/INACTIVE) of the combo package.
-Parameters:
-    - status: New state value.
-Returns:
-    - void
-*/
 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,14 +1,6 @@
-/*
-File: ComboPackage.h
-Description: Declares the ComboPackage class which represents a service package with a unique ID, package name, discount percentage, associated services, and status in the Vehicle Service Management System.
-Author: Trenser
-Date: 19-May-2026
-*/
-
 #pragma once
 #include <string>
 #include "Map.h"
-#include "Vector.h"
 #include "Enums.h"
 
 class Service;
@@ -20,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);
@@ -38,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,45 +1,13 @@
-/*
-File: InventoryItem.cpp
-Description: Implements the InventoryItem class which represents an inventory item in the Vehicle Service Management System.
-             Provides constructors, accessors, and mutators for item details such as ID, part name, quantity, price, and state.
-Author: Trenser
-Date: 19-May-2026
-*/
-
-#include <sstream>
-#include <stdexcept>
-#include "Factory.h"
-#include "StringHelper.h"
 #include "InventoryItem.h"
 
 int InventoryItem::m_uid = 0;
 
-/*
-Function: InventoryItem
-Description: Default constructor that initializes a new inventory item with a unique ID,
-             active state, zero quantity, and zero price.
-Parameters:
-    - None
-Returns:
-    - A new InventoryItem object.
-*/
 InventoryItem::InventoryItem()
     : m_id("IIM" + std::to_string(++m_uid)),
     m_quantity(0),
     m_status(util::State::ACTIVE),
     m_price(0.0) {}
 
-/*
-Function: InventoryItem
-Description: Parameterized constructor that initializes a new inventory item with a unique ID,
-             specified part name, quantity, price, and active state.
-Parameters:
-    - partName: Name of the inventory item.
-    - quantity: Initial quantity of the item.
-    - price: Price of the item.
-Returns:
-    - A new InventoryItem object.
-*/
 InventoryItem::InventoryItem(const std::string& partName, int quantity, double price)
     : m_id("IIM" + std::to_string(++m_uid)),
     m_partName(partName),
@@ -47,232 +15,52 @@ 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;
-    }
-}
-
-/*
-Function: getId
-Description: Retrieves the unique ID of the inventory item.
-Parameters:
-    - None
-Returns:
-    - const std::string& representing the item ID.
-*/
 const std::string& InventoryItem::getId() const
 {
     return m_id;
 }
 
-/*
-Function: getPartName
-Description: Retrieves the part name of the inventory item.
-Parameters:
-    - None
-Returns:
-    - const std::string& representing the part name.
-*/
 const std::string& InventoryItem::getPartName() const
 {
     return m_partName;
 }
 
-/*
-Function: getQuantity
-Description: Retrieves the current quantity of the inventory item.
-Parameters:
-    - None
-Returns:
-    - int representing the quantity.
-*/
 int InventoryItem::getQuantity() const
 {
     return m_quantity;
 }
 
-/*
-Function: getPrice
-Description: Retrieves the price of the inventory item.
-Parameters:
-    - None
-Returns:
-    - double representing the price.
-*/
 double InventoryItem::getPrice() const
 {
     return m_price;
 }
 
-/*
-Function: getState
-Description: Retrieves the current state (ACTIVE/INACTIVE) of the inventory item.
-Parameters:
-    - None
-Returns:
-    - util::State representing the item state.
-*/
 util::State InventoryItem::getState() const
 {
     return m_status;
 }
 
-/*
-Function: setId
-Description: Sets the unique ID of the inventory item.
-Parameters:
-    - id: New ID string.
-Returns:
-    - void
-*/
 void InventoryItem::setId(const std::string& id)
 {
     m_id = id;
 }
 
-/*
-Function: setPartName
-Description: Sets the part name of the inventory item.
-Parameters:
-    - partName: New part name string.
-Returns:
-    - void
-*/
 void InventoryItem::setPartName(const std::string& partName)
 {
     m_partName = partName;
 }
 
-/*
-Function: setQuantity
-Description: Sets the quantity of the inventory item.
-Parameters:
-    - quantity: New quantity value.
-Returns:
-    - void
-*/
 void InventoryItem::setQuantity(int quantity)
 {
     m_quantity = quantity;
 }
 
-/*
-Function: setPrice
-Description: Sets the price of the inventory item.
-Parameters:
-    - price: New price value.
-Returns:
-    - void
-*/
 void InventoryItem::setPrice(double price)
 {
     m_price = price;
 }
 
-/*
-Function: setState
-Description: Sets the state (ACTIVE/INACTIVE) of the inventory item.
-Parameters:
-    - status: New state value.
-Returns:
-    - void
-*/
 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

@@ -1,12 +1,3 @@
-/*
-File: InventoryItem.h
-Description: Declares the InventoryItem class which represents parts in the Vehicle Service Management System.
-             Each item has a unique ID, part name, quantity, price, and status.
-Author: Trenser
-Date: 19-May-2026
-*/
-
-
 #pragma once
 #include <string>
 #include "Enums.h"
@@ -23,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;
@@ -34,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,31 +1,7 @@
-/*
-File: Invoice.cpp
-Description: Implements the Invoice class which represents an invoice in the Vehicle Service Management System.
-             Provides constructors, accessors, and mutators for invoice details such as ID, booking, costs,
-             discount percentage, total amount, payment details, and status.
-Author: Trenser
-Date: 19-May-2026
-*/
-
-#include <sstream>
-#include <stdexcept>
 #include "Invoice.h"
-#include "Factory.h"
-#include "InventoryItem.h"
-#include "StringHelper.h"
 
 int Invoice::m_uid = 0;
 
-/*
-Function: Invoice
-Description: Default constructor that initializes a new invoice with a unique ID,
-             null booking, zero costs, zero discount, zero total amount,
-             and default payment method and status.
-Parameters:
-    - None
-Returns:
-    - A new Invoice object.
-*/
 Invoice::Invoice()
     : m_id("INV" + std::to_string(++m_uid)),
     m_booking(nullptr),
@@ -36,29 +12,11 @@ Invoice::Invoice()
     m_paymentMethod(util::PaymentMode()),
     m_status(util::PaymentStatus()) {}
 
-/*
-Function: Invoice
-Description: Parameterized constructor that initializes a new invoice with a unique ID and specified details.
-Parameters:
-    - bookingId: ID of the associated service booking.
-    - booking: Pointer to the ServiceBooking object.
-    - invoiceDate: Timestamp of when the invoice was created.
-    - laborCost: Cost of labor for the service.
-    - parts: Map of inventory items used in the service.
-    - partsCost: Total cost of parts.
-    - discountPercentage: Discount applied to the invoice.
-    - totalAmount: Final total amount after discount.
-    - paymentDate: Timestamp of when payment was made.
-    - paymentMethod: Payment mode (ONLINE/OFFLINE).
-    - status: Payment status (PENDING/COMPLETED).
-Returns:
-    - A new Invoice object.
-*/
 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, 
@@ -78,496 +36,124 @@ 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;
-    }
-}
-
-/*
-Function: getId
-Description: Retrieves the unique ID of the invoice.
-Returns:
-    - const std::string& representing the invoice ID.
-*/
 const std::string& Invoice::getId() const
 {
     return m_id;
 }
 
-/*
-Function: getBookingId
-Description: Retrieves the booking ID associated with the invoice.
-Returns:
-    - const std::string& representing the booking ID.
-*/
 const std::string& Invoice::getBookingId() const
 {
     return m_bookingId;
 }
 
-/*
-Function: getBooking
-Description: Retrieves the pointer to the associated ServiceBooking.
-Returns:
-    - ServiceBooking* representing the booking.
-*/
 ServiceBooking* Invoice::getBooking() const
 {
     return m_booking;
 }
 
-/*
-Function: getInvoiceDate
-Description: Retrieves the timestamp of the invoice creation date.
-Returns:
-    - const util::Timestamp& representing the invoice date.
-*/
 const util::Timestamp& Invoice::getInvoiceDate() const
 {
     return m_invoiceDate;
 }
 
-/*
-Function: getLaborCost
-Description: Retrieves the labor cost associated with the invoice.
-Returns:
-    - double representing the labor cost.
-*/
 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;
-}
-
-/*
-Function: getParts
-Description: Retrieves the map of inventory items used in the service.
-Returns:
-    - const util::Map<int, InventoryItem*>& representing the parts.
-*/
-const util::Map<std::string, InventoryItem*>& Invoice::getParts() const
 {
     return m_parts;
 }
 
-/*
-Function: getPartsCost
-Description: Retrieves the total cost of parts used in the service.
-Returns:
-    - double representing the parts cost.
-*/
 double Invoice::getPartsCost() const
 {
     return m_partsCost;
 }
 
-/*
-Function: getDiscountPercentage
-Description: Retrieves the discount percentage applied to the invoice.
-Returns:
-    - double representing the discount percentage.
-*/
 double Invoice::getDiscountPercentage() const
 {
     return m_discountPercentage;
 }
 
-/*
-Function: getTotalAmount
-Description: Retrieves the total amount of the invoice after discount.
-Returns:
-    - double representing the total amount.
-*/
 double Invoice::getTotalAmount() const
 {
     return m_totalAmount;
 }
 
-/*
-Function: getPaymentDate
-Description: Retrieves the timestamp of the payment date.
-Returns:
-    - const util::Timestamp& representing the payment date.
-*/
 const util::Timestamp& Invoice::getPaymentDate() const
 {
     return m_paymentDate;
 }
 
-/*
-Function: getPaymentMethod
-Description: Retrieves the payment mode used for the invoice.
-Returns:
-    - util::PaymentMode representing the payment method.
-*/
 util::PaymentMode Invoice::getPaymentMethod() const
 {
     return m_paymentMethod;
 }
 
-/*
-Function: getStatus
-Description: Retrieves the payment status of the invoice.
-Returns:
-    - util::PaymentStatus representing the payment status.
-*/
 util::PaymentStatus Invoice::getStatus() const
 {
     return m_status;
 }
 
-/*
-Function: setId
-Description: Sets the unique ID of the invoice.
-Parameters:
-    - id: New invoice ID string.
-Returns:
-    - void
-*/
 void Invoice::setId(const std::string& id)
 {
     m_id = id;
 }
 
-/*
-Function: setBookingId
-Description: Sets the booking ID associated with the invoice.
-Parameters:
-    - bookingId: New booking ID string.
-Returns:
-    - void
-*/
 void Invoice::setBookingId(const std::string& bookingId)
 {
     m_bookingId = bookingId;
 }
 
-/*
-Function: setBooking
-Description: Sets the associated ServiceBooking pointer.
-Parameters:
-    - booking: Pointer to the ServiceBooking object.
-Returns:
-    - void
-*/
 void Invoice::setBooking(ServiceBooking* booking)
 {
     m_booking = booking;
 }
 
-/*
-Function: setInvoiceDate
-Description: Sets the invoice creation date.
-Parameters:
-    - invoiceDate: New timestamp for the invoice date.
-Returns:
-    - void
-*/
 void Invoice::setInvoiceDate(const util::Timestamp& invoiceDate)
 {
     m_invoiceDate = invoiceDate;
 }
 
-/*
-Function: setLaborCost
-Description: Sets the labor cost for the invoice.
-Parameters:
-    - laborCost: New labor cost value.
-Returns:
-    - void
-*/
 void Invoice::setLaborCost(double laborCost)
 {
     m_laborCost = laborCost;
 }
 
-/*
+void Invoice::setParts(const util::Map<int, InventoryItem*>& parts)
-Function: setParts
-Description: Sets the inventory items used in the service.
-Parameters:
-    - parts: Map of inventory items.
-Returns:
-    - void
-*/
-void Invoice::setParts(const util::Map<std::string, 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());
-    }
 }
 
-/*
-Function: setPartsCost
-Description: Sets the total cost of parts used in the service.
-Parameters:
-    - partsCost: New parts cost value.
-Returns:
-    - void
-*/
 void Invoice::setPartsCost(double partsCost)
 {
     m_partsCost = partsCost;
 }
 
-/*
-Function: setDiscountPercentage
-Description: Sets the discount percentage applied to the invoice.
-Parameters:
-    - discountPercentage: New discount percentage value.
-Returns:
-    - void
-*/
 void Invoice::setDiscountPercentage(double discountPercentage)
 {
     m_discountPercentage = discountPercentage;
 }
 
-/*
-Function: setTotalAmount
-Description: Sets the total amount of the invoice.
-Parameters:
-    - totalAmount: New total amount value.
-Returns:
-    - void
-*/
 void Invoice::setTotalAmount(double totalAmount)
 {
     m_totalAmount = totalAmount;
 }
 
-/*
-Function: setPaymentDate
-Description: Sets the payment date for the invoice.
-Parameters:
-    - paymentDate: New timestamp for the payment date.
-Returns:
-    - void
-*/
 void Invoice::setPaymentDate(const util::Timestamp& paymentDate)
 {
     m_paymentDate = paymentDate;
 }
 
-/*
-Function: setPaymentMethod
-Description: Sets the payment mode for the invoice.
-Parameters:
-    - paymentMethod: New payment mode value.
-Returns:
-    - void
-*/
 void Invoice::setPaymentMethod(util::PaymentMode paymentMethod)
 {
     m_paymentMethod = paymentMethod;
 }
 
-/*
-Function: setStatus
-Description: Sets the payment status of the invoice.
-Parameters:
-    - status: New payment status value.
-Returns:
-    - void
-*/
 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,16 +1,6 @@
-/*
-File: Invoice.h
-Description: Declares the Invoice class which represents billing details for a service booking in the Vehicle Service Management System.
-             Each invoice includes booking information, labor cost, parts used, discount percentage, total amount, payment details, and status.
-Author: Trenser
-Date: 19-May-2026
-*/
-
-
 #pragma once
 #include <string>
 #include "Map.h"
-#include "Vector.h"
 #include "Timestamp.h"
 #include "Enums.h"
 
@@ -26,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, 
@@ -49,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;
@@ -80,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,30 +1,7 @@
-/*
-File: JobCard.cpp
-Description: Implements the JobCard class which represents a technician’s job assignment in the Vehicle Service Management System.
-             Provides constructors, accessors, and mutators for job details such as ID, booking, service, technician,
-             assigned date, completion date, and job status.
-Author: Trenser
-Date: 19-May-2026
-*/
-
-#include <sstream>
-#include <stdexcept>
 #include "JobCard.h"
-#include "Factory.h"
-#include "StringHelper.h"
-#include "Enums.h"
 
 int JobCard::m_uid = 0;
 
-/*
-Function: JobCard
-Description: Default constructor that initializes a new job card with a unique ID,
-             null booking, null service, null technician, and default job status.
-Parameters:
-    - None
-Returns:
-    - A new JobCard object.
-*/
 JobCard::JobCard()
     : m_id("JC" + std::to_string(++m_uid)),
     m_booking(nullptr),
@@ -32,22 +9,6 @@ JobCard::JobCard()
     m_technician(nullptr),
     m_status(util::ServiceJobStatus()) {}
 
-/*
-Function: JobCard
-Description: Parameterized constructor that initializes a new job card with a unique ID and specified details.
-Parameters:
-    - bookingId: ID of the associated service booking.
-    - booking: Pointer to the ServiceBooking object.
-    - service: Pointer to the Service object.
-    - serviceId: ID of the associated service.
-    - technicianId: ID of the assigned technician.
-    - technician: Pointer to the User object representing the technician.
-    - assignedDate: Timestamp of when the job was assigned.
-    - status: Current status of the job (STARTED/COMPLETED).
-    - completionDate: Timestamp of when the job was completed.
-Returns:
-    - A new JobCard object.
-*/
 JobCard::JobCard(const std::string& bookingId,
     ServiceBooking* booking,
     Service* service,
@@ -69,363 +30,102 @@ 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;
-    }
-}
-
-/*
-Function: getId
-Description: Retrieves the unique ID of the job card.
-Returns:
-    - const std::string& representing the job card ID.
-*/
 const std::string& JobCard::getId() const
 {
     return m_id;
 }
 
-/*
-Function: getBookingId
-Description: Retrieves the booking ID associated with the job card.
-Returns:
-    - const std::string& representing the booking ID.
-*/
 const std::string& JobCard::getBookingId() const
 {
     return m_bookingId;
 }
 
-/*
-Function: getBooking
-Description: Retrieves the pointer to the associated ServiceBooking.
-Returns:
-    - ServiceBooking* representing the booking.
-*/
 ServiceBooking* JobCard::getBooking() const
 {
     return m_booking;
 }
 
-/*
-Function: getService
-Description: Retrieves the pointer to the associated Service.
-Returns:
-    - Service* representing the service.
-*/
 Service* JobCard::getService() const
 {
     return m_service;
 }
 
-/*
-Function: getServiceId
-Description: Retrieves the service ID associated with the job card.
-Returns:
-    - const std::string& representing the service ID.
-*/
 const std::string& JobCard::getServiceId() const
 {
     return m_serviceId;
 }
 
-/*
-Function: getTechnicianId
-Description: Retrieves the technician ID associated with the job card.
-Returns:
-    - const std::string& representing the technician ID.
-*/
 const std::string& JobCard::getTechnicianId() const
 {
     return m_technicianId;
 }
 
-/*
-Function: getTechnician
-Description: Retrieves the pointer to the assigned technician.
-Returns:
-    - User* representing the technician.
-*/
 User* JobCard::getTechnician() const
 {
     return m_technician;
 }
 
-/*
-Function: getAssignedDate
-Description: Retrieves the timestamp of when the job was assigned.
-Returns:
-    - const util::Timestamp& representing the assigned date.
-*/
 const util::Timestamp& JobCard::getAssignedDate() const
 {
     return m_assignedDate;
 }
 
-/*
-Function: getStatus
-Description: Retrieves the current status of the job.
-Returns:
-    - ServiceJobStatus representing the job status.
-*/
 util::ServiceJobStatus JobCard::getStatus() const
 {
     return m_status;
 }
 
-/*
-Function: getCompletionDate
-Description: Retrieves the timestamp of when the job was completed.
-Returns:
-    - const util::Timestamp& representing the completion date.
-*/
 const util::Timestamp& JobCard::getCompletionDate() const
 {
     return m_completionDate;
 }
 
-/*
-Function: setId
-Description: Sets the unique ID of the job card.
-Parameters:
-    - id: New job card ID string.
-Returns:
-    - void
-*/
 void JobCard::setId(const std::string& id)
 {
     m_id = id;
 }
 
-/*
-Function: setBookingId
-Description: Sets the booking ID associated with the job card.
-Parameters:
-    - bookingId: New booking ID string.
-Returns:
-    - void
-*/
 void JobCard::setBookingId(const std::string& bookingId)
 {
     m_bookingId = bookingId;
 }
 
-/*
-Function: setBooking
-Description: Sets the associated ServiceBooking pointer.
-Parameters:
-    - booking: Pointer to the ServiceBooking object.
-Returns:
-    - void
-*/
 void JobCard::setBooking(ServiceBooking* booking)
 {
     m_booking = booking;
 }
 
-/*
-Function: setService
-Description: Sets the associated Service pointer.
-Parameters:
-    - service: Pointer to the Service object.
-Returns:
-    - void
-*/
 void JobCard::setService(Service* service)
 {
     m_service = service;
 }
 
-/*
-Function: setServiceId
-Description: Sets the service ID associated with the job card.
-Parameters:
-    - serviceId: New service ID string.
-Returns:
-    - void
-*/
 void JobCard::setServiceId(const std::string& serviceId)
 {
     m_serviceId = serviceId;
 }
 
-/*
-Function: setTechnicianId
-Description: Sets the technician ID associated with the job card.
-Parameters:
-    - technicianId: New technician ID string.
-Returns:
-    - void
-*/
 void JobCard::setTechnicianId(const std::string& technicianId)
 {
     m_technicianId = technicianId;
 }
 
-/*
-Function: setTechnician
-Description: Sets the pointer to the assigned technician.
-Parameters:
-    - technician: Pointer to the User object.
-Returns:
-    - void
-*/
 void JobCard::setTechnician(User* technician)
 {
     m_technician = technician;
 }
 
-/*
-Function: setAssignedDate
-Description: Sets the timestamp of when the job was assigned.
-Parameters:
-    - assignedDate: New timestamp for the assigned date.
-Returns:
-    - void
-*/
 void JobCard::setAssignedDate(const util::Timestamp& assignedDate)
 {
     m_assignedDate = assignedDate;
 }
 
-/*
-Function: setStatus
-Description: Sets the current status of the job.
-Parameters:
-    - status: New job status value.
-Returns:
-    - void
-*/
 void JobCard::setStatus(util::ServiceJobStatus status)
 {
     m_status = status;
 }
 
-/*
-Function: setCompletionDate
-Description: Sets the timestamp of when the job was completed.
-Parameters:
-    - completionDate: New timestamp for the completion date.
-Returns:
-    - void
-*/
 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,11 +1,3 @@
-/*
-File: JobCard.h
-Description: Declares the JobCard class which represents a technician’s job assignment in the Vehicle Service Management System.
-             Each job card includes booking details, associated service, technician information, assigned and completion dates, and job status.
-Author: Trenser
-Date: 19-May-2026
-*/
-
 #pragma once
 #include <string>
 #include "Timestamp.h"
@@ -42,14 +34,6 @@ public:
         util::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;
     const std::string& getBookingId() const;
     ServiceBooking* getBooking() const;
@@ -70,7 +54,4 @@ public:
     void setAssignedDate(const util::Timestamp& assignedDate);
     void setStatus(util::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,42 +1,11 @@
-/*
-File: Notification.cpp
-Description: Implements the Notification class which represents system notifications in the Vehicle Service Management System.
-             Provides constructors, accessors, and mutators for notification details such as ID, recipient, title, message, and timestamp.
-Author: Trenser
-Date: 19-May-2026
-*/
-
-#include <sstream>
 #include "Notification.h"
-#include "StringHelper.h"
-#include "Factory.h"
 
 int Notification::m_uid = 0;
 
-/*
-Function: Notification
-Description: Default constructor that initializes a new notification with a unique ID and null recipient.
-Parameters:
-    - None
-Returns:
-    - A new Notification object.
-*/
 Notification::Notification()
     : m_id("NOT" + std::to_string(++m_uid)),
     m_recipient(nullptr) {}
 
-/*
-Function: Notification
-Description: Parameterized constructor that initializes a new notification with a unique ID and specified details.
-Parameters:
-    - recipientUserId: ID of the recipient user.
-    - recipient: Pointer to the User object representing the recipient.
-    - title: Title of the notification.
-    - message: Message content of the notification.
-    - createdAt: Timestamp of when the notification was created.
-Returns:
-    - A new Notification object.
-*/
 Notification::Notification(const std::string& recipientUserId, User* recipient, const std::string& title, const std::string& message, const util::Timestamp& createdAt)
     : m_id("NOT" + std::to_string(++m_uid)),
     m_recipientUserId(recipientUserId),
@@ -45,243 +14,62 @@ 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;
-    }
-}
-
-/*
-Function: getId
-Description: Retrieves the unique ID of the notification.
-Returns:
-    - const std::string& representing the notification ID.
-*/
 const std::string& Notification::getId() const 
 {
     return m_id;
 }
 
-/*
-Function: getRecipientUserId
-Description: Retrieves the recipient user ID associated with the notification.
-Returns:
-    - const std::string& representing the recipient user ID.
-*/
 const std::string& Notification::getRecipientUserId() const
 {
     return m_recipientUserId;
 }
 
-/*
-Function: getRecipient
-Description: Retrieves the pointer to the recipient user.
-Returns:
-    - User* representing the recipient.
-*/
 User* Notification::getRecipient() const
 {
     return m_recipient;
 }
 
-/*
-Function: getTitle
-Description: Retrieves the title of the notification.
-Returns:
-    - const std::string& representing the notification title.
-*/
 const std::string& Notification::getTitle() const
 {
     return m_title;
 }
 
-/*
-Function: getMessage
-Description: Retrieves the message content of the notification.
-Returns:
-    - const std::string& representing the notification message.
-*/
 const std::string& Notification::getMessage() const
 {
     return m_message;
 }
 
-/*
-Function: getCreatedAt
-Description: Retrieves the timestamp of when the notification was created.
-Returns:
-    - const util::Timestamp& representing the creation timestamp.
-*/
 const util::Timestamp& Notification::getCreatedAt() const
 {
     return m_createdAt;
 }
 
-/*
-Function: setId
-Description: Sets the unique ID of the notification.
-Parameters:
-    - id: New notification ID string.
-Returns:
-    - void
-*/
 void Notification::setId(const std::string& id)
 {
     m_id = id;
 }
 
-/*
-Function: setRecipientUserId
-Description: Sets the recipient user ID for the notification.
-Parameters:
-    - recipientUserId: New recipient user ID string.
-Returns:
-    - void
-*/
 void Notification::setRecipientUserId(const std::string& recipientUserId)
 {
     m_recipientUserId = recipientUserId;
 }
 
-/*
-Function: setRecipient
-Description: Sets the recipient user pointer for the notification.
-Parameters:
-    - recipient: Pointer to the User object.
-Returns:
-    - void
-*/
 void Notification::setRecipient(User* recipient)
 {
     m_recipient = recipient;
 }
 
-/*
-Function: setTitle
-Description: Sets the title of the notification.
-Parameters:
-    - title: New notification title string.
-Returns:
-    - void
-*/
 void Notification::setTitle(const std::string& title)
 {
     m_title = title;
 }
 
-/*
-Function: setMessage
-Description: Sets the message content of the notification.
-Parameters:
-    - message: New notification message string.
-Returns:
-    - void
-*/
 void Notification::setMessage(const std::string& message)
 {
     m_message = message;
 }
 
-/*
-Function: setCreatedAt
-Description: Sets the timestamp of when the notification was created.
-Parameters:
-    - createdAt: New timestamp value.
-Returns:
-    - void
-*/
 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

@@ -1,11 +1,3 @@
-/*
-File: Notification.h
-Description: Declares the Notification class which represents system messages sent to users in the Vehicle Service Management System.
-             Each notification includes a unique ID, recipient details, title, message content, and timestamp of creation.
-Author: Trenser
-Date: 19-May-2026
-*/
-
 #pragma once
 #include <string>
 #include "Timestamp.h"
@@ -25,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;
@@ -38,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,337 +1,65 @@
-/*
-File: Service.cpp
-Description: Implements the Service class which represents a vehicle service in the Vehicle Service Management System.
-             Provides constructors, accessors, and mutators for service details such as ID, name, required inventory items,
-             labor cost, and state.
-Author: Trenser
-Date: 19-May-2026
-*/
-
-#include <sstream>
 #include "Service.h"
-#include "InventoryItem.h"
-#include "StringHelper.h"
-#include "Factory.h"
 
 int Service::m_uid = 0;
 
-/*
-Function: Service
-Description: Default constructor that initializes a new service with a unique ID,
-             active state, and zero labor cost.
-Parameters:
-    - None
-Returns:
-    - A new Service object.
-*/
 Service::Service()
     : m_id("SRV" + std::to_string(++m_uid)),
     m_status(util::State::ACTIVE),
     m_laborCost(0.0) {}
 
-/*
-Function: Service
-Description: Parameterized constructor that initializes a new service with a unique ID and specified details.
-Parameters:
-    - name: Name of the service.
-    - requiredInventoryItems: Map of inventory items required for the service.
-    - laborCost: Labor cost associated with the service.
-Returns:
-    - A new Service object.
-*/
 Service::Service(const std::string& name, const util::Map<std::string, InventoryItem*>& requiredInventoryItems, double laborCost)
     : m_id("SRV" + std::to_string(++m_uid)),
     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;
-    }
-}
-
-/*
-Function: getId
-Description: Retrieves the unique ID of the service.
-Returns:
-    - const std::string& representing the service ID.
-*/
 const std::string& Service::getId() const
 {
     return m_id;
 }
 
-/*
-Function: getName
-Description: Retrieves the name of the service.
-Returns:
-    - const std::string& representing the service name.
-*/
 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;
-}
-
-/*
-Function: getRequiredInventoryItems
-Description: Retrieves the map of inventory items required for the service.
-Returns:
-    - const util::Map<std::string, InventoryItem*>& representing the required inventory items.
-*/
 const util::Map<std::string, InventoryItem*>& Service::getRequiredInventoryItems() const
 {
     return m_requiredInventoryItems;
 }
 
-/*
-Function: getLaborCost
-Description: Retrieves the labor cost associated with the service.
-Returns:
-    - double representing the labor cost.
-*/
 double Service::getLaborCost() const
 {
     return m_laborCost;
 }
 
-/*
-Function: getState
-Description: Retrieves the current state (ACTIVE/INACTIVE) of the service.
-Returns:
-    - util::State representing the service state.
-*/
 util::State Service::getState() const
 {
     return m_status;
 }
 
-/*
-Function: setId
-Description: Sets the unique ID of the service.
-Parameters:
-    - id: New service ID string.
-Returns:
-    - void
-*/
 void Service::setId(const std::string& id)
 {
     m_id = id;
 }
 
-/*
-Function: setName
-Description: Sets the name of the service.
-Parameters:
-    - name: New service name string.
-Returns:
-    - void
-*/
 void Service::setName(const std::string& name)
 {
     m_name = name;
 }
 
-/*
-Function: setRequiredInventoryItems
-Description: Sets the inventory items required for the service.
-Parameters:
-    - requiredInventoryItems: Map of inventory items.
-Returns:
-    - void
-*/
 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());
-    }
 }
 
-/*
-Function: setLaborCost
-Description: Sets the labor cost for the service.
-Parameters:
-    - laborCost: New labor cost value.
-Returns:
-    - void
-*/
 void Service::setLaborCost(double laborCost)
 {
     m_laborCost = laborCost;
 }
 
-/*
-Function: setState
-Description: Sets the state (ACTIVE/INACTIVE) of the service.
-Parameters:
-    - status: New state value.
-Returns:
-    - void
-*/
 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,16 +1,6 @@
-/*
-File: Service.h
-Description: Declares the Service class which represents a vehicle service in the Vehicle Service Management System.
-             Each service includes a unique ID, name, required inventory items, labor cost, and status.
-Author: Trenser
-Date: 19-May-2026
-*/
-
-
 #pragma once
 #include <string>
 #include "Map.h"
-#include "Vector.h"
 #include "Enums.h"
 
 class InventoryItem;
@@ -21,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;
@@ -40,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,53 +1,14 @@
-/*
-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 <stdexcept>
-#include <sstream>
 #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,
-             null customer, and zero discount percentage.
-Parameters: None
-Returns: A new ServiceBooking object.
-*/
 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 new service booking with a unique ID and specified details.
-Parameters:
-    - id: Booking ID string.
-    - status: Current status of the booking (e.g., PENDING, COMPLETED).
-    - services: Map of services included in the booking.
-    - customerId: ID of the customer.
-    - customer: Pointer to the User object representing the customer.
-    - vehicleNumber: Vehicle registration number.
-    - vehicleBrand: Brand of the vehicle.
-    - vehicleModel: Model of the vehicle.
-    - assignedTechnicianId: ID of the assigned technician.
-    - assignedTechnician: Name of the assigned technician.
-    - discountPercentage: Discount applied to the booking.
-Returns:
-    - A new ServiceBooking object.
-*/
 ServiceBooking::ServiceBooking(
+    const std::string& id,
     util::ServiceJobStatus status,
     const util::Map<std::string,
     Service*>& services,
@@ -56,6 +17,8 @@ ServiceBooking::ServiceBooking(
     const std::string& vehicleNumber,
     const std::string& vehicleBrand,
     const std::string& vehicleModel,
+    const std::string& assignedTechnicianId,
+    const User* assignedTechnician,
     double discountPercentage
 )
     : m_id("SRV" + std::to_string(++m_uid)),
@@ -66,450 +29,118 @@ ServiceBooking::ServiceBooking(
     m_vehicleNumber(vehicleNumber),
     m_vehicleBrand(vehicleBrand),
     m_vehicleModel(vehicleModel),
-    m_assignedTechnicianId(""),
-    m_assignedTechnician(nullptr),
-    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_assignedTechnician(assignedTechnician),
     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
-Description: Retrieves the IDs of services booked.
-Parameters:
-    - None
-Returns:
-    - const util::Vector<std::string>&: Service IDs
-*/
-const util::Vector<std::string>& ServiceBooking::getServiceIDs() const
-{
-    return m_serviceIDs;
-}
-
-/*
-Function: getServices
-Description: Retrieves the services associated with the booking.
-Parameter: None
-Return type: const util::Map<std::string, Service*>&
-*/
 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;
 }
 
-/*
+void ServiceBooking::setAssignedTechnician(const User* assignedTechnician)
-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,15 +1,6 @@
-/*
-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;
@@ -21,7 +12,6 @@ private:
     static int m_uid;
     std::string m_id;
     util::ServiceJobStatus m_status;
-    util::Vector<std::string> m_serviceIDs;
     util::Map<std::string, Service*> m_services;
     std::string m_customerId;
     User* m_customer;
@@ -29,11 +19,12 @@ private:
     std::string m_vehicleBrand;
     std::string m_vehicleModel;
     std::string m_assignedTechnicianId;
-    User* m_assignedTechnician;
+    const User* m_assignedTechnician;
     double m_discountPercentage;
 public:
     ServiceBooking();
     ServiceBooking(
+        const std::string& id,
         util::ServiceJobStatus status,
         const util::Map<std::string,
         Service*>& services,
@@ -42,22 +33,12 @@ public:
         const std::string& vehicleNumber,
         const std::string& vehicleBrand,
         const std::string& vehicleModel,
-        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,
+        const User* assignedTechnician,
         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;
@@ -65,7 +46,7 @@ public:
     const std::string& getVehicleBrand() const;
     const std::string& getVehicleModel() const;
     const std::string& getAssignedTechnicianId() const;
-    User* getAssignedTechnician() const;
+    const User* getAssignedTechnician() const;
     double getDiscountPercentage() const;
     void setId(const std::string& id);
     void setStatus(const util::ServiceJobStatus& status);
@@ -76,9 +57,6 @@ public:
     void setVehicleBrand(const std::string& vehicleBrand);
     void setVehicleModel(const std::string& vehicleModel);
     void setAssignedTechnicianId(const std::string& assignedTechnicianId);
-    void setAssignedTechnician(User* assignedTechnician);
+    void setAssignedTechnician(const 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,48 +1,14 @@
-/*
-File: User.cpp
-Description: Implements the User class which represents system users in the Vehicle Service Management System.
-             Provides constructors, destructor, accessors, and mutators for user details such as ID, username,
-             password, name, phone, email, role, state, and notifications.
-Author: Trenser
-Date: 19-May-2026
-*/
-
-#include <sstream>
 #include "User.h"
 #include "Notification.h"
 #include "Enums.h"
-#include "Factory.h"
-#include "StringHelper.h"
 
 int User::m_uid = 0;
 
-/*
-Function: User
-Description: Default constructor that initializes a new user with a unique ID,
-             default role as CUSTOMER, and active state.
-Parameters:
-    - None
-Returns:
-    - A new User object.
-*/
 User::User()
     : m_id("USR" + std::to_string(++m_uid)),
     m_type(util::UserType::CUSTOMER),
     m_status(util::State::ACTIVE) {}
 
-/*
-Function: User
-Description: Parameterized constructor that initializes a new user with a unique ID and specified details.
-Parameters:
-    - userName: Username for login.
-    - password: Password for authentication.
-    - name: Full name of the user.
-    - phone: Phone number of the user.
-    - email: Email address of the user.
-    - role: Role of the user (CUSTOMER, ADMIN, TECHNICIAN, etc.).
-Returns:
-    - A new User object.
-*/
 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)
     : m_id("USR" + std::to_string(++m_uid)),
     m_userName(userName),
@@ -53,339 +19,104 @@ 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;
-    }
-}
-
-/*
-Function: ~User
-Description: Destructor that cleans up dynamically allocated notifications associated with the user.
-Parameters:
-    - None
-Returns:
-    - void
-*/
 User::~User()
 {
-    auto values = m_notifications.getValues();
+    for (int index = 0; index < m_notifications.getSize(); index++)
-    for (int index = 0; index < values.getSize(); index++)
     {
-        delete values[index];
+        delete m_notifications.getValues()[index];
     }
 }
 
-/*
-Function: getId
-Description: Retrieves the unique ID of the user.
-Returns:
-    - const std::string& representing the user ID.
-*/
 const std::string& User::getId() const
 {
     return m_id;
 }
 
-/*
-Function: getUserName
-Description: Retrieves the username of the user.
-Returns:
-    - const std::string& representing the username.
-*/
 const std::string& User::getUserName() const
 {
     return m_userName;
 }
 
-/*
-Function: getPassword
-Description: Retrieves the password of the user.
-Returns:
-    - const std::string& representing the password.
-*/
 const std::string& User::getPassword() const
 {
     return m_password;
 }
 
-/*
-Function: getName
-Description: Retrieves the full name of the user.
-Returns:
-    - const std::string& representing the name.
-*/
 const std::string& User::getName() const
 {
     return m_name;
 }
 
-/*
-Function: getPhone
-Description: Retrieves the phone number of the user.
-Returns:
-    - const std::string& representing the phone number.
-*/
 const std::string& User::getPhone() const
 {
     return m_phone;
 }
 
-/*
-Function: getEmail
-Description: Retrieves the email address of the user.
-Returns:
-    - const std::string& representing the email.
-*/
 const std::string& User::getEmail() const
 {
     return m_email;
 }
 
-/*
-Function: getNotifications
-Description: Retrieves the map of notifications associated with the user.
-Returns:
-    - util::Map<std::string, Notification*>& representing the notifications.
-*/
 util::Map<std::string, Notification*>& User::getNotifications()
 {
     return m_notifications;
 }
 
-/*
-Function: getUserType
-Description: Retrieves the role of the user.
-Returns:
-    - util::UserType representing the user role.
-*/
 util::UserType User::getUserType() const
 {
     return m_type;
 }
 
-/*
-Function: getState
-Description: Retrieves the current state (ACTIVE/INACTIVE) of the user.
-Returns:
-    - util::State representing the user state.
-*/
 util::State User::getState() const
 {
     return m_status;
 }
 
-/*
-Function: setId
-Description: Sets the unique ID of the user.
-Parameters:
-    - id: New user ID string.
-Returns:
-    - void
-*/
 void User::setId(const std::string& id)
 {
     m_id = id;
 }
 
-/*
-Function: setUserName
-Description: Sets the username of the user.
-Parameters:
-    - userName: New username string.
-Returns:
-    - void
-*/
 void User::setUserName(const std::string& userName)
 {
     m_userName = userName;
 }
 
-/*
-Function: setPassword
-Description: Sets the password of the user.
-Parameters:
-    - password: New password string.
-Returns:
-    - void
-*/
 void User::setPassword(const std::string& password)
 {
     m_password = password;
 }
 
-/*
-Function: setName
-Description: Sets the full name of the user.
-Parameters:
-    - name: New name string.
-Returns:
-    - void
-*/
 void User::setName(const std::string& name)
 {
     m_name = name;
 }
 
-/*
-Function: setPhone
-Description: Sets the phone number of the user.
-Parameters:
-    - phone: New phone number string.
-Returns:
-    - void
-*/
 void User::setPhone(const std::string& phone)
 {
     m_phone = phone;
 }
 
-/*
-Function: setEmail
-Description: Sets the email address of the user.
-Parameters:
-    - email: New email string.
-Returns:
-    - void
-*/
 void User::setEmail(const std::string& email)
 {
     m_email = email;
 }
 
-/*
-Function: addNotification
-Description: Adds a new notification to the user’s notification map.
-Parameters:
-    - notification: Pointer to the Notification object.
-Returns:
-    - void
-*/
 void User::addNotification(Notification* notification)
-{
-    if (notification)
 {
     m_notifications.insert(notification->getId(), notification);
 }
-}
 
-/*
-Function: setRole
-Description: Sets the role of the user.
-Parameters:
-    - role: New user role value.
-Returns:
-    - void
-*/
 void User::setRole(util::UserType role)
 {
     m_type = role;
 }
 
-/*
-Function: setState
-Description: Sets the state (ACTIVE/INACTIVE) of the user.
-Parameters:
-    - status: New state value.
-Returns:
-    - void
-*/
 void User::setState(util::State status)
 {
     m_status = 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

@@ -1,12 +1,3 @@
-/*
-File: User.h
-Description: Declares the User class which represents system users in the Vehicle Service Management System.
-             Each user has a unique ID, credentials, personal details, notifications, role type, and status.
-             The User class also implements the Observer interface to handle notifications.
-Author: Trenser
-Date: 19-May-2026
-*/
-
 #pragma once
 #include <string>
 #include "Map.h"
@@ -31,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;
@@ -48,10 +38,8 @@ public:
     void setName(const std::string& name);
     void setPhone(const std::string& phone);
     void setEmail(const std::string& email);
-    void addNotification(Notification* notification) override;
+    void addNotification(Notification* notification);
     void setRole(util::UserType role);
     void setState(util::State status);
-    std::string serialize() const;
+    void update(Notification* notification) override;
-    static User* deserialize(const std::string&);
-    static std::string getHeaders();
 };

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

@@ -1,81 +1,3 @@
-/*
-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,11 +1,3 @@
-/*
-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,253 +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 <stdexcept>
-#include "Config.h"
-#include "Enums.h"
-#include "Factory.h"
-#include "FileManager.h"
-#include "InventoryItem.h"
 #include "InventoryManagementService.h"
-#include "Timestamp.h"
-#include "User.h"
-#include "Utility.h"
-#include "Vector.h"
-
-util::Map<std::string, User*> InventoryManagementService::m_observers{};
-
-/*
-Function: attach
-Description: Adds a user to the observer list for receiving inventory notifications.
-Parameters:
-	- user: User*, pointer to the user to be attached as an observer
-Returns:
-	- None
-*/
-void InventoryManagementService::attach(User* user)
-{
-	if (user)
-	{
-		const std::string& userID = user->getId();
-		if (m_observers.find(userID) == -1)
-		{
-			m_observers[userID] = user;
-		}
-	}
-}
-
-/*
-Function: detach
-Description: Removes a user from the observer list so they no longer receive inventory notifications.
-Parameters:
-	- user: User*, pointer to the user to be detached from the observer list
-Returns:
-	- None
-*/
-void InventoryManagementService::detach(User* user)
-{
-	if (user)
-	{
-		const std::string& userID = user->getId();
-		if (m_observers.find(userID) != -1)
-		{
-			m_observers.remove(userID);
-		}
-	}
-}
-
-/*
-Function: sendNotification
-Description: Sends a notification to a user if they are subscribed as an observer.
-Parameters:
-	- user: User*, pointer to the user receiving the notification
-	- title: std::string, title of the notification
-	- message: std::string, body/content of the notification
-Returns:
-	- None
-Throws:
-	- std::runtime_error if notification creation fails
-*/
-void InventoryManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
-{
-	if (user)
-	{
-		if (m_observers.find(user->getId()) != -1)
-		{
-			Notification* notification =
-				Factory::getObject<Notification>(
-					user->getId(),
-					user,
-					"InventoryManagementService: " + title,
-					message,
-					util::Timestamp()
-				);
-			if (notification)
-			{
-				user->addNotification(notification);
-			}
-			else
-			{
-				throw std::runtime_error("Failed to create notification");
-			}
-		}
-	}
-}
-
-/*
-Function: sendLowStockAlertsToAdmins (static helper)
-Description: Sends low stock alert notifications to all admin users for a given inventory item.
-Parameters:
-	- inventoryManagementService: InventoryManagementService&, service used to send notifications
-	- inventoryItem: const InventoryItem*, pointer to the low-stock inventory item
-	- adminUsers: const util::Vector<User*>&, list of admin users to notify
-Returns:
-	- None
-*/
-static void sendLowStockAlertsToAdmins(InventoryManagementService& inventoryManagementService, const InventoryItem* inventoryItem, const util::Vector<User*>& adminUsers)
-{
-	int adminUsersSize = adminUsers.getSize();
-	for (int index = 0; index < adminUsersSize; index++)
-	{
-		std::string title = "Low Stock Alert";
-		std::string message = "The inventory item with ID " + inventoryItem->getId() + " has very low quantity in the inventory";
-		inventoryManagementService.sendNotification(
-			adminUsers[index],
-			title,
-			message
-		);
-	}
-}
-
-/*
-Function: sendLowStockAlerts
-Description: Sends alerts to user for inventory items with low stock
-Parameters:
-	- None
-Returns:
-	- None
-*/
-void InventoryManagementService::sendLowStockAlerts()
-{
-	auto& inventoryItems = m_dataStore.getInventoryItems();
-	int inventoryItemsSize = inventoryItems.getSize();
-	auto& usersMap = m_dataStore.getUsers();
-	int usersMapSize = usersMap.getSize();
-	util::Vector<User*> adminUsers;
-	for (int index = 0; index < usersMapSize; index++)
-	{
-		User* user = usersMap.getValueAt(index);
-		if (user->getUserType() == util::UserType::ADMIN)
-		{
-			adminUsers.push_back(user);
-		}
-	}
-	int adminUsersSize = adminUsers.getSize();
-	if (adminUsersSize < 1)
-	{
-		throw std::runtime_error("The system has no admins present!");
-	}
-	for (int index = 0; index <= inventoryItemsSize; index++)
-	{
-		InventoryItem* inventoryItem = inventoryItems.getValueAt(index);
-		if (inventoryItem && inventoryItem->getQuantity() < config::threshold::INVENTORY_LOW_STOCK_THRESHOLD)
-		{
-			sendLowStockAlertsToAdmins(*this, inventoryItem, adminUsers);
-		}
-	}
-}
-
-/*
-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,15 +1,6 @@
-/*
-File: InventoryManagementService.h
-Description: Declares the InventoryManagementService class which manages inventory operations in the Vehicle Service Management System.
-             Provides functionality to retrieve, add, and remove inventory items, send low stock alerts, and handle notifications using the Observer pattern.
-Author: Trenser
-Date: 19-May-2026
-*/
-
 #pragma once
 #include <string>
 #include "Map.h"
-#include "Vector.h"
 #include "NotificationManagementService.h"
 #include "DataStore.h"
 
@@ -20,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();
@@ -31,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

@@ -1,15 +1,6 @@
-/*
-File: NotificationManagementService.h
-Description: Declares the NotificationManagementService abstract class which defines the contract for managing notifications in the Vehicle Service Management System.
-			 Implements the Subject interface and provides pure virtual methods for sending notifications and managing user subscriptions (attach/detach).
-Author: Trenser
-Date: 19-May-2026
-*/
-
 #pragma once
 #include <string>
 #include "Subject.h"
-#include "Notification.h"
 #include "User.h"
 
 class NotificationManagementService : public Subject
@@ -19,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,255 +1 @@
-/*
-File: PaymentManagementService.cpp
-Description: Implements the PaymentManagementService class which manages payment-related operations
-			 in the Vehicle Service Management System. Provides functionality for attaching/detaching observers,
-			 sending notifications, and issuing payment reminders based on invoice status and thresholds.
-Author: Trenser
-Date: 20-May-2026
-*/
-
-#include <stdexcept>
-#include "Config.h"
-#include "Enums.h"
-#include "Factory.h"
-#include "FileManager.h"
-#include "Invoice.h"
 #include "PaymentManagementService.h"
-#include "ServiceBooking.h"
-#include "Timestamp.h"
-#include "User.h"
-#include "Utility.h"
-
-util::Map<std::string, User*> PaymentManagementService::m_observers{};
-
-/*
-Function: attach
-Description: Attaches a user as an observer to the PaymentManagementService for receiving notifications.
-Parameters:
-	- user: Pointer to the User object to be attached.
-Returns:
-	- void
-*/
-void PaymentManagementService::attach(User* user)
-{
-	if (user)
-	{
-		const std::string& userID = user->getId();
-		if (m_observers.find(userID) == -1)
-		{
-			m_observers[userID] = user;
-		}
-	}
-}
-
-/*
-Function: detach
-Description: Detaches a user from the observer list of the PaymentManagementService.
-Parameters:
-	- user: Pointer to the User object to be detached.
-Returns:
-	- void
-*/
-void PaymentManagementService::detach(User* user)
-{
-	if (user)
-	{
-		const std::string& userID = user->getId();
-		if (m_observers.find(userID) != -1)
-		{
-			m_observers.remove(userID);
-		}
-	}
-}
-
-/*
-Function: sendNotification
-Description: Sends a notification to a user if they are registered as an observer.
-Parameters:
-	- user: Pointer to the User object to receive the notification.
-	- title: Title of the notification.
-	- message: Message content of the notification.
-Returns:
-	- void
-Throws:
-	- std::runtime_error if notification creation fails.
-*/
-void PaymentManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
-{
-	if (user)
-	{
-		if (m_observers.find(user->getId()) != -1)
-		{
-			Notification* notification =
-				Factory::getObject<Notification>(
-					user->getId(),
-					user,
-					"PaymentManagementService: " + title,
-					message,
-					util::Timestamp()
-				);
-			if (notification)
-			{
-				user->addNotification(notification);
-			}
-			else
-			{
-				throw std::runtime_error("Failed to create notification");
-			}
-		}
-	}
-}
-
-/*
-Function: sendPaymentReminders
-Description: Iterates through all invoices in the datastore and sends payment reminders to customers
-			 whose invoices are pending beyond the configured threshold duration.
-Parameters:
-	- None
-Returns:
-	- void
-*/
-void PaymentManagementService::sendPaymentReminders()
-{
-	auto& invoicesMap = m_dataStore.getInvoices();
-	int invoicesMapSize = invoicesMap.getSize();
-	for (int index = 0; index < invoicesMapSize; index++)
-	{
-		const Invoice* invoice = invoicesMap.getValueAt(index);
-		if (invoice && invoice->getStatus() == util::PaymentStatus::PENDING)
-		{
-			util::Timestamp invoiceCreationTimestamp = invoice->getInvoiceDate();
-			util::Timestamp currentTimestamp;
-			if (util::Timestamp::getDurationInHours(invoiceCreationTimestamp, currentTimestamp) >= config::threshold::PAYMENT_REMINDER_THRESHOLD_HOURS)
-			{
-				const ServiceBooking* serviceBooking = invoice->getBooking();
-				if (serviceBooking)
-				{
-					User* customer = serviceBooking->getCustomer();
-					if (customer)
-					{
-						std::string title = "Payment Reminder";
-						std::string message = "Your payment for Invoice ID " + invoice->getId() + " is still pending. Please complete the payment.";
-						sendNotification(customer, title, message);
-					}
-				}
-			}
-		}
-	}
-}
-
-/*
-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

@@ -1,12 +1,3 @@
-/*
-File: PaymentManagementService.h
-Description: Declares the PaymentManagementService class which manages payment operations in the Vehicle Service Management System.
-             Provides functionality to generate invoices, retrieve customer invoices, complete payments, send payment reminders,
-             and handle notifications using the Observer pattern.
-Author: Trenser
-Date: 19-May-2026
-*/
-
 #pragma once
 #include <string>
 #include "Map.h"
@@ -22,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);
@@ -32,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,502 +1,324 @@
-/*
-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 "AuthenticationManagementService.h"
-#include "ComboPackage.h"
-#include "Config.h"
-#include "Factory.h"
-#include "FileManager.h"
-#include "JobCard.h"
-#include "Service.h"
-#include "ServiceBooking.h"
 #include "ServiceManagementService.h"
+#include "UserManagementService.h"
+#include "ServiceBooking.h"
+#include "Factory.h"
+#include "JobCard.h"
 #include "Timestamp.h"
+#include "Service.h"
+#include "Enums.h"
+#include "InventoryItem.h"
+#include "AuthenticationManagementService.h"
+#include "PaymentManagementService.h"
+#include "NotificationManagementService.h"
 #include "User.h"
-#include "Utility.h"
 
 /*
-Function: purchaseService
+Function: getServiceBookings
-Description: Creates a new service booking for the authenticated user. Validates
+Description: Retrieves all service bookings from the datastore.
-			 service IDs, retrieves services from the DataStore, and generates a
-			 booking. Sends a notification upon successful booking.
-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 ServiceManagementService::purchaseService(const util::Vector<std::string>& serviceIDs, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
-{
-	AuthenticationManagementService m_authenticationManagementService;
-	auto authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
-	if (authenticatedUser == nullptr)
-	{
-		throw std::runtime_error("No user is currently logged in!");
-	}
-	auto& servicesMap = m_dataStore.getServices();
-	auto& serviceBookingMap = m_dataStore.getServiceBookings();
-	util::Map<std::string, Service*> selectedServices;
-	int selectedServicesCount = serviceIDs.getSize();
-	for (int index = 0; index < selectedServicesCount; index++)
-	{
-		int serviceIndex = servicesMap.find(serviceIDs[index]);
-		if (serviceIndex == -1)
-		{
-			throw std::runtime_error("Service not found!");
-		}
-		Service* service = servicesMap.getValueAt(serviceIndex);
-		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("Failed to create service booking");
-	}
-	serviceBookingMap[serviceBooking->getId()] = serviceBooking;
-    std::string title = "Service Booking succeeded";
-    std::string message = "Your service booking has been successfully placed with ID " + serviceBooking->getId();
-    sendNotification(authenticatedUser, title, message);
-}
-
-/*
-Function: purchaseComboPackage
-Description: Creates a new service booking for a combo package. Validates the combo
-			 package ID, retrieves services from the package, and generates a booking
-			 with the applicable discount. Sends a notification upon successful booking.
-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 ServiceManagementService::purchaseComboPackage(const std::string& comboPackageID, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
-{
-	AuthenticationManagementService m_authenticationManagementService;
-	auto authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
-	if (authenticatedUser == nullptr)
-	{
-		throw std::runtime_error("No user is currently logged in!");
-	}
-	auto& comboPackagesMap = m_dataStore.getComboPackages();
-	auto& serviceBookingMap = m_dataStore.getServiceBookings();
-	int comboPackageIndex = comboPackagesMap.find(comboPackageID);
-	if (comboPackageIndex == -1)
-	{
-		throw std::runtime_error("Combo Package not found!");
-	}
-	const ComboPackage* comboPackage = comboPackagesMap[comboPackageID];
-	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());
-	if (serviceBooking == nullptr)
-	{
-		throw std::runtime_error("Failed to create combo package service booking");
-	}
-	serviceBookingMap[serviceBooking->getId()] = serviceBooking;
-    std::string title = "Combo Package Service Booking succeeded";
-    std::string message = "Your service booking for the combo package has been successfully placed with ID " + serviceBooking->getId();
-    sendNotification(authenticatedUser, title, message);
-}
-
-util::Map<std::string, User*> ServiceManagementService::m_observers{};
-
-/*
-Function: attach
-Description: Attaches a user as an observer to the ServiceManagementService for receiving notifications.
 Parameters:
-	- user: Pointer to the User object to be attached.
+	- None
 Returns:
-	- void
+	- util::Map<std::string, ServiceBooking*> containing all service bookings
 */
-void ServiceManagementService::attach(User* user)
+util::Map<std::string, ServiceBooking*> ServiceManagementService::getServiceBookings()
 {
-	if (user)
+	return m_dataStore.getServiceBookings();
-	{
-		const std::string& userID = user->getId();
-		if (m_observers.find(userID) == -1)
-		{
-			m_observers[userID] = user;
-		}
-	}
 }
 
 /*
-Function: detach
+Function: getServiceBooking
-Description: Detaches a user from the observer list of the ServiceManagementService.
+Description: Retrieves a specific service booking by its ID.
 Parameters:
-	- user: Pointer to the User object to be detached.
+	- serviceID: std::string, ID of the service booking
 Returns:
-	- void
+	- ServiceBooking*: Pointer to the service booking, or nullptr if not found
 */
-void ServiceManagementService::detach(User* user)
+ServiceBooking* ServiceManagementService::getServiceBooking(const std::string& serviceID)
 {
-	if (user)
+	auto currentServiceBookings = getServiceBookings();
+	for (int iterator = 0; iterator < currentServiceBookings.getSize(); iterator++)
 	{
-		const std::string& userID = user->getId();
+		if (currentServiceBookings.getValueAt(iterator)->getId() == serviceID)
-		if (m_observers.find(userID) != -1)
 		{
-			m_observers.remove(userID);
+			return currentServiceBookings.getValueAt(iterator);
 		}
 	}
+	return nullptr;
 }
 
 /*
-Function: sendNotification
+Function: createJobCard
-Description: Sends a notification to a user if they are registered as an observer.
+Description: Creates a job card for a given service booking, service, and technician.
+			 Validates booking, service, technician, and inventory availability before creation.
 Parameters:
-	- user: Pointer to the User object to receive the notification.
+	- bookingID: std::string, ID of the service booking
-	- title: Title of the notification.
+	- technicianID: std::string, ID of the technician
-	- message: Message content of the notification.
+	- serviceID: std::string, ID of the service
 Returns:
 	- void
 Throws:
-	- std::runtime_error if notification creation fails.
+	- std::runtime_error if booking, service, technician, or inventory validation fails
 */
-void ServiceManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
+void ServiceManagementService::createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID)
 {
-	if (user)
+	UserManagementService m_userManagementService;
+	ServiceBooking* currentBooking = getServiceBooking(bookingID);
+	auto& currentJobCards = m_dataStore.getJobCards();
+	if (currentBooking == nullptr)
 	{
-		if (m_observers.find(user->getId()) != -1)
+		throw std::runtime_error("Service Booking not available");
+	}
+	auto& currentServices = currentBooking->getServices();
+	if (currentServices.find(serviceID) == -1)
 	{
-			Notification* notification =
+		throw std::runtime_error("Invalid service Id");
-				Factory::getObject<Notification>(
+	}
-					user->getId(),
+	Service* currentService = currentServices.getValueAt(currentServices.find(serviceID));
-					user,
+	User* selectedTechnician = m_userManagementService.getUser(technicianID);
-					"ServiceManagementService: " + title,
+	if (selectedTechnician == nullptr)
-					message,
-					util::Timestamp()
-				);
-			if (notification)
 	{
-				user->addNotification(notification);
+		throw std::runtime_error("Technician not available");
+	}
+	auto& inventoryItems = currentService->getRequiredInventoryItems();
+	for (int iterator = 0; iterator < inventoryItems.getSize(); iterator++)
+	{
+		InventoryItem* currentInventoryItem = inventoryItems.getValueAt(iterator);
+		if (currentInventoryItem->getQuantity() == 0)
+		{
+			std::string errorMessage = "Failed to create job card, " + currentInventoryItem->getPartName() + " is out of stock.";
+			throw std::runtime_error(errorMessage);
 		}
 		else
 		{
-				throw std::runtime_error("Failed to create notification");
+			int currentStockQuantity = currentInventoryItem->getQuantity();
-			}
+			currentInventoryItem->setQuantity(currentStockQuantity - 1);
 		}
 	}
+	currentBooking->setAssignedTechnician(selectedTechnician);
+	currentBooking->setAssignedTechnicianId(selectedTechnician->getId());
+	std::string title = "Job card created";
+	std::string message = "Job card created for the service and you are assigned for that.";
+	JobCard* jobCard = Factory::getObject<JobCard>(bookingID, currentBooking, currentService, serviceID, technicianID, selectedTechnician, util::Timestamp(), util::ServiceJobStatus::STARTED, util::Timestamp());
+	currentJobCards.insert(jobCard->getId(), jobCard);
+	sendNotification(selectedTechnician,title, message);
 }
 
 /*
-Function: getObserverIDs
+Function: createService
-Description: Retrieves the IDs of all observers currently attached to the
+Description: Creates a new service with associated inventory items and labor cost.
-             ServiceManagementService.
+			 Validates inventory items before creation.
 Parameters:
-    - None
+	- name: std::string, name of the service
-Returns:
+	- inventoryItemIDs: util::Vector<std::string>, IDs of required inventory items
-    - util::Vector<std::string>: Vector of observer user IDs
+	- laborCost: double, labor cost for the service
-*/
-util::Vector<std::string> ServiceManagementService::getObserverIDs()
-{
-	util::Vector<std::string> observerIDs;
-	int numberOfObservers = m_observers.getSize();
-	for (int index = 0; index < numberOfObservers; index++)
-	{
-		User* observer = m_observers.getValueAt(index);
-		if (observer)
-		{
-			observerIDs.push_back(observer->getId());
-		}
-	}
-	return observerIDs;
-}
-
-/*
-Function: loadServices
-Description: Loads services from persistent storage into the datastore.
-             Validates required inventory items and attaches them to each service.
-Parameters:
-    - None
 Returns:
 	- void
 Throws:
-    - std::runtime_error if an inventory item ID is invalid
+	- std::runtime_error if inventory items are not found or service creation fails
 */
-void ServiceManagementService::loadServices()
+void ServiceManagementService::createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost)
 {
-    util::FileManager<Service> serviceFileManager(config::file::SERVICE_FILE);
+	util::Map<std::string, InventoryItem*> currentServiceInventoryItems;
-    auto& services = m_dataStore.getServices();
+	auto inventoryItems = m_dataStore.getInventoryItems();
-    auto& inventoryItems = m_dataStore.getInventoryItems();
+	for (int iteratorOne =0; iteratorOne < inventoryItemIDs.getSize(); iteratorOne++)
-    auto servicesMap = serviceFileManager.load();
-    for (int serviceIndex = 0; serviceIndex < servicesMap.getSize(); serviceIndex++)
 	{
-        Service* service = servicesMap.getValueAt(serviceIndex);
+		std::string currentItemID = inventoryItemIDs[iteratorOne];
-        services[service->getId()] = service;
+		bool itemFound = false;
-        util::Map<std::string, InventoryItem*> inventoryItemsMap;
+		for (int iteratorTwo = 0; iteratorTwo < inventoryItems.getSize(); iteratorTwo++)
-        auto& inventoryItemIDs = service->getRequiredInventoryItemIDs();
-        for (int inventoryItemIndex = 0; inventoryItemIndex < inventoryItemIDs.getSize(); inventoryItemIndex++)
 		{
-            const std::string& inventoryItemID = inventoryItemIDs[inventoryItemIndex];
+			InventoryItem* currentInventoryItem = inventoryItems.getValueAt(iteratorTwo);
-            int index = inventoryItems.find(inventoryItemID);
+			if (currentInventoryItem && currentInventoryItem->getId() == currentItemID)
-            if (index == -1)
 			{
-                throw std::runtime_error("Invalid Inventory Item ID");
+				itemFound = true;
+				currentServiceInventoryItems.insert(currentInventoryItem->getId(), currentInventoryItem);
+				break;
 			}
-            inventoryItemsMap[inventoryItemID] = inventoryItems.getValueAt(index);
 		}
-        service->setRequiredInventoryItems(inventoryItemsMap);
+		if (!itemFound)
+		{
+			throw std::runtime_error("Inventory item with ID '" + currentItemID + "' not found.");
 		}
 	}
+	Service* newService = Factory::getObject<Service>(name, currentServiceInventoryItems, laborCost);
+	if (newService == nullptr)
+	{
+		throw std::runtime_error("Unable to create new service.");
+	}
+	util::Map<std::string, Service*>& currentServices = m_dataStore.getServices();
+	if (currentServices.find(newService->getId()) != -1)
+	{
+		throw std::runtime_error("Service with this ID Already exists.");
+	}
+	currentServices.insert(newService->getId(), newService);
+}
 
 /*
-Function: saveServices
+Function: getServices
-Description: Saves services from the datastore to persistent storage.
+Description: Retrieves all services from the datastore.
-             Uses FileManager to serialize services into the configured file.
 Parameters:
 	- None
 Returns:
-    - void
+	- util::Map<std::string, Service*> containing all services
 */
-void ServiceManagementService::saveServices()
+util::Map<std::string, Service*> ServiceManagementService::getServices()
 {
-	util::FileManager<Service> serviceFileManager(config::file::SERVICE_FILE);
+	return m_dataStore.getServices();
-	auto& services = m_dataStore.getServices();
-	serviceFileManager.save(services);
 }
 
 /*
-Function: loadComboPackages
+Function: removeService
-Description: Loads combo packages from persistent storage into the datastore.
+Description: Marks a service as inactive by its ID.
-             Validates associated services and attaches them to each package.
 Parameters:
-    - None
+	- serviceID: std::string, ID of the service
 Returns:
 	- void
 Throws:
-    - std::runtime_error if a service ID is invalid
+	- std::runtime_error if the service is not found
 */
-void ServiceManagementService::loadComboPackages()
+void ServiceManagementService::removeService(const std::string& serviceID)
 {
-    util::FileManager<ComboPackage> comboPackageFileManager(config::file::COMBOPACKAGE_FILE);
+	util::Map<std::string, Service*> currentServices = getServices();
-    auto& comboPackages = m_dataStore.getComboPackages();
+	if (currentServices.find(serviceID) != -1)
-    auto& services = m_dataStore.getServices();
-    auto comboPackagesMap = comboPackageFileManager.load();
-    for (int packageIndex = 0; packageIndex < comboPackagesMap.getSize(); packageIndex++)
 	{
-        ComboPackage* comboPackage = comboPackagesMap.getValueAt(packageIndex);
+		currentServices.getValueAt(currentServices.find(serviceID))->setState(util::State::INACTIVE);
-        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);
+	else
-        }
+	{
-        comboPackage->setServices(packageServices);
+		throw std::runtime_error("Service not found.");
-        comboPackages[comboPackage->getId()] = comboPackage;
 	}
 }
 
 /*
-Function: saveComboPackages
+Function: getServiceBookings (overloaded)
-Description: Saves combo packages from the datastore to persistent storage.
+Description: Retrieves all service bookings for a specific customer.
-             Uses FileManager to serialize combo packages into the configured file.
 Parameters:
-    - None
+	- customerID: std::string, ID of the customer
 Returns:
-    - void
+	- util::Map<std::string, ServiceBooking*> containing bookings for the customer
 */
-void ServiceManagementService::saveComboPackages()
+util::Map<std::string, ServiceBooking*> ServiceManagementService::getServiceBookings(const std::string& customerID)
 {
-    util::FileManager<ComboPackage> comboPackageFileManager(config::file::COMBOPACKAGE_FILE);
+	util::Map<std::string, ServiceBooking*> currentServiceBookings = getServiceBookings();
-    auto& comboPackages = m_dataStore.getComboPackages();
+	util::Map<std::string, ServiceBooking*> currentUserServiceBookings;
-    comboPackageFileManager.save(comboPackages);
+	if (currentServiceBookings.getSize() != 0)
+	{
+		for (int iterator = 0; iterator < currentServiceBookings.getSize(); iterator++)
+		{
+			auto currentServiceBooking = currentServiceBookings.getValueAt(iterator);
+			if (currentServiceBooking->getCustomerId() == customerID)
+			{
+				currentUserServiceBookings.insert(currentServiceBooking->getId(), currentServiceBooking);
+			}
+		}
+	}
+	return currentUserServiceBookings;
 }
 
 /*
-Function: loadServiceBookings
+Function: getJobCards
-Description: Loads service bookings from persistent storage into the datastore.
+Description: Retrieves all job cards assigned to a specific technician.
-             Validates associated services, customers, and technicians before
-             attaching them to each booking.
 Parameters:
-    - None
+	- technicianID: std::string, ID of the technician
+Returns:
+	- util::Map<std::string, JobCard*> containing job cards assigned to the technician
+*/
+util::Map<std::string, JobCard*> ServiceManagementService::getJobCards(const std::string& technicianID)
+{
+	util::Map<std::string, JobCard*> jobCards = m_dataStore.getJobCards();
+	util::Map<std::string, JobCard*> technicianJobCards;
+	for (int iterator = 0; iterator < jobCards.getSize(); iterator++)
+	{
+		JobCard* currentJobCard = jobCards.getValueAt(iterator);
+		if (currentJobCard->getTechnicianId() == technicianID)
+		{
+			technicianJobCards.insert(currentJobCard->getId(), currentJobCard);
+		}
+	}
+	return technicianJobCards;
+}
+
+/*
+Function: hasAllJobCardsinServiceBookingCompleted (static helper)
+Description: Checks if all job cards for a given service booking are completed.
+Parameters:
+	- bookingId: std::string, ID of the service booking
+	- currentAssignedJobs: util::Map<std::string, JobCard*>&, map of assigned job cards
+Returns:
+	- bool: True if all job cards are completed, False otherwise
+*/
+static bool hasAllJobCardsinServiceBookingCompleted(std::string bookingId, util::Map<std::string, JobCard*>& currentAssignedJobs)
+{
+	for (int iterator = 0; iterator < currentAssignedJobs.getSize(); iterator++)
+	{
+		JobCard* currentJob = currentAssignedJobs.getValueAt(iterator);
+		if (currentJob->getBookingId() == bookingId)
+		{
+			if (currentJob->getStatus() == util::ServiceJobStatus::STARTED)
+			{
+				return false;
+			}
+		}
+	}
+	return true;
+}
+
+/*
+Function: completeJob
+Description: Marks a job card as completed for the authenticated technician.
+			 If all job cards in the booking are completed, marks the booking as completed
+			 and generates an invoice.
+Parameters:
+	- jobID: std::string, ID of the job card
 Returns:
 	- void
 Throws:
-    - std::runtime_error if a service ID, customer ID, or technician ID is invalid
+	- std::runtime_error if technician is not authenticated, job card not found, or job already completed
-    - std::runtime_error if a user is not of the expected type (customer/technician)
 */
-void ServiceManagementService::loadServiceBookings()
+void ServiceManagementService::completeJob(const std::string& jobID)
 {
-    util::FileManager<ServiceBooking> bookingFileManager(config::file::SERVICEBOOKING_FILE);
+	AuthenticationManagementService authenticationManagementService;
-    auto& serviceBookings = m_dataStore.getServiceBookings();
+	PaymentManagementService paymentManagementService;
-    auto& services = m_dataStore.getServices();
+	bool jobStatusUpdated = false, serviceBookingCompleted;
-    auto& users = m_dataStore.getUsers();
+	JobCard* currentJob;
-    auto bookingsMap = bookingFileManager.load();
+	User* currentTechnician = authenticationManagementService.getAuthenticatedUser();
-    for (int bookingIndex = 0; bookingIndex < bookingsMap.getSize(); bookingIndex++)
+	if (currentTechnician == nullptr)
 	{
-        ServiceBooking* booking = bookingsMap.getValueAt(bookingIndex);
+		throw std::runtime_error("Unable to fetch current technician.");
-        util::Map<std::string, Service*> bookingServices;
+	}
-        auto& serviceIDs = booking->getServiceIDs();
+	util::Map<std::string, JobCard*> currentAssignedJobs = getJobCards(currentTechnician->getId());
-        for (int serviceIndex = 0; serviceIndex < serviceIDs.getSize(); serviceIndex++)
+	if (currentAssignedJobs.getSize() == 0)
 	{
-            const std::string& serviceID = serviceIDs[serviceIndex];
+		throw std::runtime_error("No job cards assigned to the technician.");
-            int serviceMapIndex = services.find(serviceID);
+	}
-            if (serviceMapIndex == -1)
+	if (currentAssignedJobs.find(jobID) != -1)
 	{
-                throw std::runtime_error("Invalid Service ID");
+		currentJob = currentAssignedJobs.getValueAt(currentAssignedJobs.find(jobID));
+		if (currentJob == nullptr)
+		{
+			throw std::runtime_error("Unable to fetch current job.");
+		}
+		if (currentJob->getStatus() == util::ServiceJobStatus::STARTED)
+		{
+			currentJob->setStatus(util::ServiceJobStatus::COMPLETED);
+			jobStatusUpdated = true;
+		}
+	}
+	else
+	{
+		throw std::runtime_error("Failed to complete the job, some error occured or job already completed.");
+	}
+	if (!jobStatusUpdated)
+	{
+		throw std::runtime_error("Failed to complete the job, some error occured or job already completed.");
 	}
 
-            bookingServices[serviceID] = services.getValueAt(serviceMapIndex);
+	serviceBookingCompleted = hasAllJobCardsinServiceBookingCompleted(currentJob->getBookingId(), currentAssignedJobs);
-        }
+	if (serviceBookingCompleted)
-        booking->setServices(bookingServices);
-        int customerIndex = users.find(booking->getCustomerId());
-        if (customerIndex == -1)
 	{
-            throw std::runtime_error("Invalid Customer ID");
+		currentJob->getBooking()->setStatus(util::ServiceJobStatus::COMPLETED);
-        }
+		paymentManagementService.generateInvoice(currentJob->getBooking());
-        User* customer = users.getValueAt(customerIndex);
+		std::string title = "Service Booking completed,Invoice Generated.\n";
-        if (customer->getUserType() != util::UserType::CUSTOMER)
+		std::string message = "Services completed for the booking and invoice generated.\n";
-        {
+		sendNotification(currentJob->getBooking()->getCustomer(), title, message);
-            throw std::runtime_error("User is not a customer");
-        }
-        booking->setCustomer(customer);
-        const std::string& technicianId = booking->getAssignedTechnicianId();
-        if (!technicianId.empty())
-        {
-            int technicianIndex = users.find(technicianId);
-            if (technicianIndex == -1)
-            {
-                throw std::runtime_error("Invalid Technician ID");
-            }
-            User* technician = users.getValueAt(technicianIndex);
-            if (technician->getUserType() != util::UserType::TECHNICIAN)
-            {
-                throw std::runtime_error("User is not a technician");
-            }
-            booking->setAssignedTechnician(technician);
-        }
-        serviceBookings[booking->getId()] = booking;
 	}
 }
-
-/*
-Function: saveServiceBookings
-Description: Saves service bookings from the datastore to persistent storage.
-             Uses FileManager to serialize bookings into the configured file.
-Parameters:
-    - None
-Returns:
-    - void
-*/
-void ServiceManagementService::saveServiceBookings()
-{
-    util::FileManager<ServiceBooking> bookingFileManager(config::file::SERVICEBOOKING_FILE);
-    auto& serviceBookings = m_dataStore.getServiceBookings();
-    bookingFileManager.save(serviceBookings);
-}
-
-/*
-Function: loadJobCards
-Description: Loads job cards from persistent storage into the datastore.
-             Validates associated bookings, services, and technicians before
-             attaching them to each job card.
-Parameters:
-    - None
-Returns:
-    - void
-Throws:
-    - std::runtime_error if a booking ID, service ID, or technician ID is invalid
-    - std::runtime_error if a service does not belong to the booking
-    - std::runtime_error if a user is not a technician
-*/
-void ServiceManagementService::loadJobCards()
-{
-    util::FileManager<JobCard> jobCardFileManager(config::file::JOBCARD_FILE);
-    auto& jobCards = m_dataStore.getJobCards();
-    auto& serviceBookings = m_dataStore.getServiceBookings();
-    auto& services = m_dataStore.getServices();
-    auto& users = m_dataStore.getUsers();
-    auto jobCardsMap = jobCardFileManager.load();
-    for (int jobCardIndex = 0; jobCardIndex < jobCardsMap.getSize(); jobCardIndex++)
-    {
-        JobCard* jobCard = jobCardsMap.getValueAt(jobCardIndex);
-        int bookingIndex = serviceBookings.find(jobCard->getBookingId());
-        if (bookingIndex == -1)
-        {
-            throw std::runtime_error("Invalid Booking ID");
-        }
-        ServiceBooking* booking = serviceBookings.getValueAt(bookingIndex);
-        jobCard->setBooking(booking);
-        int serviceIndex = services.find(jobCard->getServiceId());
-        if (serviceIndex == -1)
-        {
-            throw std::runtime_error("Invalid Service ID");
-        }
-        Service* service = services.getValueAt(serviceIndex);
-        if (booking->getServices().find(jobCard->getServiceId()) == -1)
-        {
-            throw std::runtime_error("Service does not belong to booking");
-        }
-        jobCard->setService(service);
-        int technicianIndex = users.find(jobCard->getTechnicianId());
-        if (technicianIndex == -1)
-        {
-            throw std::runtime_error("Invalid Technician ID");
-        }
-        User* technician = users.getValueAt(technicianIndex);
-        if (technician->getUserType() != util::UserType::TECHNICIAN)
-        {
-            throw std::runtime_error("User is not a technician");
-        }
-        jobCard->setTechnician(technician);
-        jobCards[jobCard->getId()] = jobCard;
-    }
-}
-
-/*
-Function: saveJobCards
-Description: Saves job cards from the datastore to persistent storage.
-             Uses FileManager to serialize job cards into the configured file.
-Parameters:
-    - None
-Returns:
-    - void
-*/
-void ServiceManagementService::saveJobCards()
-{
-    util::FileManager<JobCard> jobCardFileManager(config::file::JOBCARD_FILE);
-    auto& jobCards = m_dataStore.getJobCards();
-    jobCardFileManager.save(jobCards);
-}
-
-/*
-Function: loadObservers
-Description: Loads observer IDs from persistent storage and attaches corresponding
-             users as observers to the ServiceManagementService.
-Parameters:
-    - None
-Returns:
-    - void
-Throws:
-    - std::runtime_error if an observer ID is invalid (not found in datastore)
-*/
-void ServiceManagementService::loadObservers()
-{
-    util::loadObservers(config::file::SERVICEMANAGEMENTOBSERVERS, this, m_dataStore);
-}
-
-/*
-Function: saveObservers
-Description: Saves the current observer IDs of the ServiceManagementService
-             to persistent storage for future retrieval.
-Parameters:
-    - None
-Returns:
-    - void
-*/
-void ServiceManagementService::saveObservers()
-{
-    util::saveObservers(config::file::SERVICEMANAGEMENTOBSERVERS, this);
-}

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

@@ -1,11 +1,3 @@
-/*
-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"
@@ -22,7 +14,6 @@ class ServiceManagementService : public NotificationManagementService
 private:
     DataStore& m_dataStore;
     static util::Map<std::string, User*> m_observers;
-    util::Vector<std::string> getObserverIDs() override;
 public:
     ServiceManagementService() : m_dataStore(DataStore::getInstance()) {}
     util::Map<std::string, Service*> getServices();
@@ -31,6 +22,7 @@ public:
     void purchaseComboPackage(const std::string& comboPackageID, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel);
     util::Map<std::string, ServiceBooking*> getServiceBookings();
     util::Map<std::string, ServiceBooking*> getServiceBookings(const std::string& customerID);
+    ServiceBooking* getServiceBooking(const std::string& serviceID);
     void createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID);
     void createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost);
     void removeService(const std::string& serviceID);
@@ -43,14 +35,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,246 +1,31 @@
-/*
-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 "Config.h"
-#include "Enums.h"
-#include "Factory.h"
-#include "FileManager.h"
-#include "InventoryManagementService.h"
-#include "Notification.h"
-#include "PaymentManagementService.h"
-#include "ServiceManagementService.h"
-#include "User.h"
 #include "UserManagementService.h"
-#include "Vector.h"
+#include "User.h"
 
-
+util::Map<std::string, User*> UserManagementService::getUsers(util::UserType type)
-/*
-Function: ensureAdminExists
-Description: Ensures that at least one admin user exists in the system.
-			 If no admin is found, creates a default admin user using
-			 configuration constants.
-Parameter: None
-Return type: void
-*/
-void UserManagementService::ensureAdminExists()
 {
-	auto& usersMap = m_dataStore.getUsers();
+	util::Map<std::string, User*>& currentUsers = m_dataStore.getUsers();
-	int usersMapSize = usersMap.getSize();
+	util::Map<std::string, User*> filteredUsersMap;
-	bool isAdminFound = false;
+	for (int iterator = 0; iterator < currentUsers.getSize(); iterator++)
-	for (int index = 0; index < usersMapSize; index++)
 	{
-		User* user = usersMap.getValueAt(index);
+		User* currentUser = currentUsers.getValueAt(iterator);
-		if (user && user->getUserType() == util::UserType::ADMIN)
+		if (currentUser->getUserType() == type)
 		{
-			isAdminFound = true;
+			filteredUsersMap.insert(currentUser->getId(), currentUser);
-			break;
 		}
 	}
-	if (!isAdminFound)
+	return filteredUsersMap;
-	{
-		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);
-	}
 }
 
-/*
+User* UserManagementService::getUser(const std::string& userID)
-Function: createUser
-Description: Creates a new user with the provided details. Validates that
-			 the username is unique, then attaches the user to relevant
-			 management services (payment, service, inventory).
-Parameter: const std::string& username - user’s username
-		   const std::string& name - user’s name
-		   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::createUser(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone, util::UserType type)
 {
-	InventoryManagementService inventoryManagementService;
+	util::Map<std::string, User*>& currentUsers = m_dataStore.getUsers();
-	PaymentManagementService paymentManagementService;
+	for (int iterator = 0; iterator < currentUsers.getSize(); iterator++)
-	ServiceManagementService serviceManagementService;
-	auto& usersMap = m_dataStore.getUsers();
-	int index = usersMap.findIf(
-		[&](const std::string&, User* user)
 	{
-			return user->getUserName() == username;
+		User* currentUser = currentUsers.getValueAt(iterator);
-		}
+		if (currentUser->getId() == userID)
-	);
-	if (index != -1)
 		{
-		throw std::runtime_error("Username already exists");
+			return currentUser;
-	}
-	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);
 		}
 	}
-
+	return nullptr;
-/*
-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);
-}
-
-/*
-Function: getUserNotifications
-Description: Retrieves all notifications associated with a given user ID.
-Parameters:
-	- userID: The unique ID of the user whose notifications are to be retrieved.
-Returns:
-	- util::Vector<Notification*> containing all notifications for the user.
-Throws:
-	- std::runtime_error if no user is found with the given UserID or if the User object is invalid.
-*/
-util::Vector<Notification*> UserManagementService::getUserNotifications(const std::string& userID)
-{
-	auto& usersMap = m_dataStore.getUsers();
-	if (usersMap.find(userID) == -1)
-	{
-		throw std::runtime_error("No user found with given UserID");
-	}
-	User* user = usersMap[userID];
-	if (user)
-	{
-		auto& notifications = user->getNotifications();
-		int numberOfNotifications = notifications.getSize();
-		util::Vector<Notification*> notificationsVector;
-		for (int index = 0; index < numberOfNotifications; index++)
-		{
-		    notificationsVector.push_back(notifications.getValueAt(index));
-		}
-		return notificationsVector;
-	}
-	else
-	{
-		throw std::runtime_error("Invalid User object");
-	}
-}
-
-/*
-Function: deleteNotification
-Description: Deletes a specific notification associated with a given user ID.
-Parameters:
-	- notificationID: The unique ID of the notification to be deleted.
-	- userID: The unique ID of the user whose notification is to be deleted.
-Returns:
-	- void
-Throws:
-	- std::runtime_error if no user is found with the given UserID or if no notification is found with the given NotificationID.
-*/
-void UserManagementService::deleteNotification(const std::string& notificationID, const std::string& userID)
-{
-	auto& usersMap = m_dataStore.getUsers();
-	if (usersMap.find(userID) == -1)
-	{
-		throw std::runtime_error("No user found with given UserID");
-	}
-	User* user = usersMap[userID];
-	auto& notifications = user->getNotifications();
-	if (notifications.find(notificationID) == -1)
-	{
-		throw std::runtime_error("No notification found with given NotificationID");
-	}
-	notifications.remove(notificationID);
-}
-
-/*
-Function: loadUsers
-Description: Loads users and notifications from persistent storage into the datastore.
-             Validates that each notification’s recipient exists and attaches the
-             notification to the corresponding user.
-Parameters:
-    - None
-Returns:
-    - void
-Throws:
-    - std::runtime_error if a notification recipient user ID is invalid
-*/
-void UserManagementService::loadUsers()
-{
-    util::FileManager<User> userFileManager(config::file::USER_FILE);
-    util::FileManager<Notification> notificationFileManager(config::file::NOTIFICATION_FILE);
-    auto& users = m_dataStore.getUsers();
-    auto usersMap = userFileManager.load();
-    auto notificationsMap = notificationFileManager.load();
-    int numberOfUsers = usersMap.getSize();
-    int numberOfNotifications = notificationsMap.getSize();
-    for (int index = 0; index < numberOfUsers; index++)
-    {
-        users[usersMap.getKeyAt(index)] = usersMap.getValueAt(index);
-    }
-    for (int index = 0; index < numberOfNotifications; index++)
-    {
-        Notification* notification = notificationsMap.getValueAt(index);
-        const std::string& recipientUserId = notification->getRecipientUserId();
-        int userIndex = users.find(recipientUserId);
-        if (userIndex == -1)
-        {
-            throw std::runtime_error("Invalid recipient user ID");
-        }
-        User* user = users.getValueAt(userIndex);
-        user->addNotification(notification);
-    }
-}
-
-/*
-Function: saveUsers
-Description: Saves users and their notifications from the datastore to persistent storage.
-             Collects notifications from all users into a single map before saving.
-Parameters:
-    - None
-Returns:
-    - void
-*/
-void UserManagementService::saveUsers()
-{
-    util::FileManager<User> userFileManager(config::file::USER_FILE);
-    util::FileManager<Notification> notificationFileManager(config::file::NOTIFICATION_FILE);
-    auto& users = m_dataStore.getUsers();
-    util::Map<std::string, Notification*> notifications;
-    for (int userIndex = 0; userIndex < users.getSize(); userIndex++)
-    {
-        User* user = users.getValueAt(userIndex);
-        auto& userNotifications = user->getNotifications();
-        for (int notificationIndex = 0; notificationIndex < userNotifications.getSize(); notificationIndex++)
-        {
-            notifications[userNotifications.getKeyAt(notificationIndex)] =
-                userNotifications.getValueAt(notificationIndex);
-        }
-    }
-    userFileManager.save(users);
-    notificationFileManager.save(notifications);
 }

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

@@ -1,11 +1,3 @@
-/*
-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"
@@ -21,7 +13,7 @@ private:
     DataStore& m_dataStore;
 public:
     UserManagementService() : m_dataStore(DataStore::getInstance()) {}
-    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 createUser(const std::string& username, 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);
@@ -29,7 +21,4 @@ public:
     void removeUser(const std::string& userID);
     util::Vector<Notification*> getUserNotifications(const std::string& userID);
     void deleteNotification(const std::string& notificationID, const std::string& userID);
-    void ensureAdminExists();
-    void loadUsers();
-    void saveUsers();
 };

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

@@ -1,43 +0,0 @@
-/*
-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: 21-May-2026
-*/
-
-#pragma once
-
-namespace config
-{
-	namespace admin
-	{
-		constexpr const char* DEFAULT_ADMIN_USERNAME = "admin";
-		constexpr const char* DEFAULT_ADMIN_NAME = "admin";
-		constexpr const char* DEFAULT_ADMIN_PASSWORD = "";
-		constexpr const char* DEFAULT_ADMIN_EMAIL = "admin@vss";
-		constexpr const char* DEFAULT_ADMIN_PHONE = "0000000000";
-	}
-
-	namespace threshold
-	{
-		constexpr int INVENTORY_LOW_STOCK_THRESHOLD = 5;
-		constexpr int PAYMENT_REMINDER_THRESHOLD_HOURS = 168;
-	}
-
-	namespace file
-	{
-		constexpr const char* INVENTORYITEM_FILE = "files/InventoryItem.csv";
-		constexpr const char* USER_FILE = "files/User.csv";
-		constexpr const char* NOTIFICATION_FILE = "files/Notification.csv";
-		constexpr const char* SERVICE_FILE = "files/Service.csv";
-		constexpr const char* COMBOPACKAGE_FILE = "files/ComboPackage.csv";
-		constexpr const char* SERVICEBOOKING_FILE = "files/ServiceBooking.csv";
-		constexpr const char* JOBCARD_FILE = "files/JobCard.csv";
-		constexpr const char* INVOICE_FILE = "files/Invoice.csv";
-		constexpr const char* SERVICEMANAGEMENTOBSERVERS = "files/ServiceManagementObservers.csv";
-		constexpr const char* PAYMENTMANAGEMENTOBSERVERS = "files/PaymentManagementObservers.csv";
-		constexpr const char* INVENTORYMANAGEMENTOBSERVERS = "files/InventoryManagementObservers.csv";
-	}
-}

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

@@ -1,12 +1,3 @@
-/*
-File: Enums.h
-Description: Declares enumerations and utility functions for user types, payment modes, payment status,
-             service job status, and state management in the Vehicle Service Management System.
-             Provides string conversion and parsing functions for each enum type.
-Author: Trenser
-Date: 19-May-2026
-*/
-
 #pragma once
 #include <stdexcept>
 
@@ -33,6 +24,7 @@ namespace util
 
 	enum class ServiceJobStatus
 	{
+        PENDING,
 		STARTED,
 		COMPLETED
 	};
@@ -43,14 +35,6 @@ namespace util
         INACTIVE
     };
 
-    /*
-    Function: getUserTypeString
-    Description: Converts a UserType enum value to its corresponding string representation.
-    Parameters:
-        - type: UserType enum value.
-    Returns:
-        - std::string representing the UserType.
-    */
     inline std::string getUserTypeString(UserType type)
     {
         switch (type)
@@ -65,16 +49,6 @@ namespace util
         throw std::invalid_argument("Invalid UserType");
     }
 
-    /*
-    Function: getUserType
-    Description: Converts a string value to its corresponding UserType enum.
-    Parameters:
-        - value: std::string representing the UserType.
-    Returns:
-        - UserType enum value.
-    Throws:
-        - std::invalid_argument if the string does not match a valid UserType.
-    */
     inline UserType getUserType(const std::string& value)
     {
         if (value == "ADMIN")
@@ -92,14 +66,6 @@ namespace util
         throw std::invalid_argument("Invalid UserType string");
     }
 
-    /*
-    Function: getPaymentModeString
-    Description: Converts a PaymentMode enum value to its corresponding string representation.
-    Parameters:
-        - mode: PaymentMode enum value.
-    Returns:
-        - std::string representing the PaymentMode.
-    */
     inline std::string getPaymentModeString(PaymentMode mode)
     {
         switch (mode)
@@ -112,16 +78,6 @@ namespace util
         throw std::invalid_argument("Invalid PaymentMode");
     }
 
-    /*
-    Function: getPaymentMode
-    Description: Converts a string value to its corresponding PaymentMode enum.
-    Parameters:
-        - value: std::string representing the PaymentMode.
-    Returns:
-        - PaymentMode enum value.
-    Throws:
-        - std::invalid_argument if the string does not match a valid PaymentMode.
-    */
     inline PaymentMode getPaymentMode(const std::string& value)
     {
         if (value == "ONLINE")
@@ -135,14 +91,6 @@ namespace util
         throw std::invalid_argument("Invalid PaymentMode string");
     }
 
-    /*
-    Function: getPaymentStatusString
-    Description: Converts a PaymentStatus enum value to its corresponding string representation.
-    Parameters:
-        - status: PaymentStatus enum value.
-    Returns:
-        - std::string representing the PaymentStatus.
-    */
     inline std::string getPaymentStatusString(PaymentStatus status)
     {
         switch (status)
@@ -155,16 +103,6 @@ namespace util
         throw std::invalid_argument("Invalid PaymentStatus");
     }
 
-    /*
-    Function: getPaymentStatus
-    Description: Converts a string value to its corresponding PaymentStatus enum.
-    Parameters:
-        - value: std::string representing the PaymentStatus.
-    Returns:
-        - PaymentStatus enum value.
-    Throws:
-        - std::invalid_argument if the string does not match a valid PaymentStatus.
-    */
     inline PaymentStatus getPaymentStatus(const std::string& value)
     {
         if (value == "PENDING")
@@ -180,14 +118,6 @@ namespace util
         throw std::invalid_argument("Invalid PaymentStatus string");
     }
 
-    /*
-    Function: getServiceJobStatusString
-    Description: Converts a ServiceJobStatus enum value to its corresponding string representation.
-    Parameters:
-        - status: ServiceJobStatus enum value.
-    Returns:
-        - std::string representing the ServiceJobStatus.
-    */
     inline std::string getServiceJobStatusString(ServiceJobStatus status)
     {
         switch (status)
@@ -196,20 +126,12 @@ namespace util
             return "STARTED";
         case ServiceJobStatus::COMPLETED:
             return "COMPLETED";
+        case ServiceJobStatus::PENDING:
+            return "STARTED";
         }
         throw std::invalid_argument("Invalid ServiceJobStatus");
     }
 
-    /*
-    Function: getServiceJobStatus
-    Description: Converts a string value to its corresponding ServiceJobStatus enum.
-    Parameters:
-        - value: std::string representing the ServiceJobStatus.
-    Returns:
-        - ServiceJobStatus enum value.
-    Throws:
-        - std::invalid_argument if the string does not match a valid ServiceJobStatus.
-    */
     inline ServiceJobStatus getServiceJobStatus(const std::string& value)
     {
         if (value == "STARTED")
@@ -223,43 +145,25 @@ namespace util
         throw std::invalid_argument("Invalid ServiceJobStatus string");
     }
 
-    /*
-    Function: getStateString
-    Description: Converts a State enum value to its corresponding string representation.
-    Parameters:
-        - status: State enum value.
-    Returns:
-        - std::string representing the State.
-    */
     inline std::string getStateString(State status)
     {
         switch (status)
         {
         case State::ACTIVE:
-            return "ACTIVE";
+            return "STARTED";
         case State::INACTIVE:
-            return "INACTIVE";
+            return "COMPLETED";
         }
         throw std::invalid_argument("Invalid State");
     }
 
-    /*
-    Function: getState
-    Description: Converts a string value to its corresponding State enum.
-    Parameters:
-        - value: std::string representing the State.
-    Returns:
-        - State enum value.
-    Throws:
-        - std::invalid_argument if the string does not match a valid State.
-    */
     inline State getState(const std::string& value)
     {
         if (value == "ACTIVE")
         {
             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,117 +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 <string>
-#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,103 +0,0 @@
-/*
-File: Utility.h
-Description: Header file declaring utility functions used across the system,
-             including cost calculation for services and combo packages.
-Author: Trenser
-Date:19-May-2026
-*/
-
-#pragma once
-#include "DataStore.h"
-#include "FileHelper.h"
-#include "InventoryItem.h"
-#include "NotificationManagementService.h"
-#include "Service.h"
-#include "ComboPackage.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;
-        auto& requiredInventoryItems = service->getRequiredInventoryItems();
-        int requiredInventoryItemsSize = requiredInventoryItems.getSize();
-        for (int index = 0; index < requiredInventoryItemsSize; index++)
-        {
-            cost += requiredInventoryItems.getValueAt(index)->getPrice();
-        }
-        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;
-    }
-
-    /*
-    Function: loadObservers
-    Description: Loads observer IDs from a file and attaches the corresponding users
-                 to the notification management service. Validates that each observer ID
-                 exists in the datastore before attaching.
-    Parameters:
-        - filePath: const std::string&, path to the file containing observer IDs
-        - service: NotificationManagementService*, pointer to the notification service
-        - dataStore: DataStore&, reference to the datastore containing users
-    Returns:
-        - void
-    Throws:
-        - std::runtime_error if an observer ID is invalid (not found in datastore)
-    */
-    inline void loadObservers(const std::string& filePath, NotificationManagementService* service, DataStore& dataStore)
-    {
-        auto observerIDs = util::loadRecords(filePath);
-        auto& users = dataStore.getUsers();
-        for (int index = 0; index < observerIDs.getSize(); index++)
-        {
-            const std::string& observerID = observerIDs[index];
-            int userIndex = users.find(observerID);
-            if (userIndex == -1)
-            {
-                throw std::runtime_error("Invalid Observer ID");
-            }
-            service->attach(users.getValueAt(userIndex));
-        }
-    }
-
-    /*
-    Function: saveObservers
-    Description: Saves the current observer IDs from the notification management service
-                 to a file for persistence.
-    Parameters:
-        - filePath: const std::string&, path to the file where observer IDs will be saved
-        - service: NotificationManagementService*, pointer to the notification service
-    Returns:
-        - void
-    */
-    inline void saveObservers(const std::string& filePath, NotificationManagementService* service)
-    {
-        auto observerIDs = service->getObserverIDs();
-        util::saveRecords(filePath, observerIDs);
-    }
-}

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

@@ -1,27 +1,13 @@
-/*
+#include <iomanip>
-File: AdminMenu.cpp
-Description: Implements the AdminMenu class which provides the administrator’s console interface
-			 in the Vehicle Service Management System. Handles menu display, user input, and
-			 admin-specific operations such as inventory management, technician management,
-			 service creation, combo package management, job assignment, and notifications.
-Author: Trenser
-Date: 19-May-2026
-*/
-
 #include "AdminMenu.h"
+#include "Service.h"
 #include "InputHelper.h"
 #include "OutputHelper.h"
-#include "MenuHelper.h"
+#include "ServiceBooking.h"
+#include "Enums.h"
+#include "Service.h"
+#include "InventoryItem.h"
 
-/*
-Function: showMenu
-Description: Displays the admin menu in a loop until the user chooses to logout.
-			 Handles exceptions and ensures smooth user interaction.
-Parameters:
-	- None
-Returns:
-	- void
-*/
 void AdminMenu::showMenu()
 {
 	bool isMenuActive = true;
@@ -76,16 +62,368 @@ void AdminMenu::checkStockAvailability()
 {
 }
 
+/*
+Function: listServiceBookings (static helper)
+Description: Lists all pending service bookings and maps them to indices for selection.
+Parameters:
+	- currentBookings: util::Map<std::string, const ServiceBooking*>&, current bookings
+	- bookingsSize: int&, number of bookings
+	- serviceBookingsMap: util::Map<int, const ServiceBooking*>&, map of indexed bookings
+Returns:
+	- bool: True if pending services exist, False otherwise
+*/
+static bool listServiceBookings(util::Map<std::string, const ServiceBooking*>& currentBookings, int& bookingsSize, util::Map<int, const ServiceBooking*>& serviceBookingsMap)
+{
+	int currentIndex = 1;
+	bool hasPendingService = false;
+	std::cout << std::left
+		<< std::setw(10) << "Index"
+		<< std::setw(10) << "ID"
+		<< std::setw(12) << "Status"
+		<< std::setw(12) << "CustID"
+		<< std::setw(20) << "Customer"
+		<< std::setw(15) << "VehicleNo"
+		<< std::setw(15) << "Brand"
+		<< std::setw(15) << "Model"
+		<< std::setw(20) << "Technician"
+		<< std::setw(15) << "TechID"
+		<< std::endl;
+	for (int iterator = 0; iterator < bookingsSize; iterator++)
+	{
+		const ServiceBooking* currentBooking = currentBookings.getValueAt(iterator);
+		if (currentBooking && currentBooking->getStatus() == util::ServiceJobStatus::PENDING)
+		{
+			hasPendingService = true;
+			std::cout << std::left
+				<< std::setw(10) << currentIndex
+				<< std::setw(10) << currentBooking->getId()
+				<< std::setw(12) << util::getServiceJobStatusString(currentBooking->getStatus())
+				<< std::setw(12) << currentBooking->getCustomerId()
+				<< std::setw(20) << currentBooking->getCustomer()->getName()
+				<< std::setw(15) << currentBooking->getVehicleNumber()
+				<< std::setw(15) << currentBooking->getVehicleBrand()
+				<< std::setw(15) << currentBooking->getVehicleModel()
+				<< std::setw(20) << (currentBooking->getAssignedTechnician() == nullptr ? "Null" : currentBooking->getAssignedTechnician()->getName())
+				<< std::setw(15) << (currentBooking->getAssignedTechnicianId().empty() ? "Null" : currentBooking->getAssignedTechnicianId())
+				<< std::endl;
+			serviceBookingsMap.insert(currentIndex++, currentBooking);
+		}
+	}
+	if (!hasPendingService)
+	{
+		std::cout << "No pending service available." << std::endl;
+		return false;
+	}
+	return true;
+}
+
+/*
+Function: selectPendingServiceBookings (static helper)
+Description: Allows selection of a pending service booking by index.
+Parameters:
+	- serviceBookingsMap: util::Map<int, const ServiceBooking*>&, map of indexed bookings
+Returns:
+	- const ServiceBooking*: Pointer to the selected booking, or nullptr if invalid
+*/
+static const ServiceBooking* selectPendingServiceBookings(util::Map<int, const ServiceBooking*>& serviceBookingsMap)
+{
+	int userInputIndex;
+	std::cout << "Enter a valid service index: ";
+	util::read(userInputIndex);
+	if (serviceBookingsMap.find(userInputIndex) != -1)
+	{
+		return serviceBookingsMap.getValueAt(userInputIndex);
+	}
+	else
+	{
+		std::cout << "Enter a valid index.";
+		return nullptr;
+	}
+}
+
+/*
+Function: listAvailableTechnicians (static helper)
+Description: Lists all available technicians and maps them to indices for selection.
+Parameters:
+	- currentAvailableTechnicians: util::Map<std::string, const User*>, available technicians
+	- numberOfTechnicians: int, number of technicians
+	- currentAvailableTechniciansMap: util::Map<int, const User*>&, map of indexed technicians
+Returns:
+	- void
+*/
+static void listAvailableTechnicians( util::Map<std::string, const User*> currentAvailableTechnicians, int numberOfTechnicians, util::Map<int, const User*>& currentAvailableTechniciansMap)
+{
+	bool hasTechnicians = false;
+	int currentIndex = 1;
+	std::cout << std::left
+		<< std::setw(6) << "Index"
+		<< std::setw(15) << "Technician ID"
+		<< std::setw(20) << "Name"
+		<< std::endl;
+	for (int iterator = 0; iterator < numberOfTechnicians; iterator++)
+	{
+		const User* currentTechnician = currentAvailableTechnicians.getValueAt(iterator);
+		if (currentTechnician->getState() == util::State::INACTIVE)
+		{
+			continue;
+		}
+		hasTechnicians = true;
+		std::cout << std::left
+			<< std::setw(6) << currentIndex
+			<< std::setw(15) << currentTechnician->getId()
+			<< std::setw(20) << currentTechnician->getName()
+			<< std::endl;
+		currentAvailableTechniciansMap.insert(currentIndex++, currentTechnician);
+	}
+	if (!hasTechnicians)
+	{
+		std::cout << "No technicians currently available.";
+	}
+}
+
+/*
+Function: selectTechnician (static helper)
+Description: Allows selection of a technician by index.
+Parameters:
+	- currentAvailableTechniciansMap: util::Map<int, const User*>&, map of indexed technicians
+Returns:
+	- const User*: Pointer to the selected technician, or nullptr if invalid
+*/
+static const User* selectTechnician(util::Map<int, const User*>& currentAvailableTechniciansMap)
+{
+	int userInputIndex;
+	util::read(userInputIndex);
+	if (currentAvailableTechniciansMap.find(userInputIndex) != -1)
+	{
+		return currentAvailableTechniciansMap.getValueAt(userInputIndex);
+	}
+	else
+	{
+		std::cout << "Enter a valid index.";
+		return nullptr;
+	}
+}
+
+/*
+Function: assignJob
+Description: Allows the admin to assign pending service bookings to available technicians.
+			 Creates job cards for selected services.
+Parameters:
+	- None
+Returns:
+	- void
+*/
 void AdminMenu::assignJob()
 {
+	util::clear();
+	std::string selectedService;
+	bool hasPendingService = false;
+	auto currentBookings = m_controller.getServiceBookings();
+	auto availableTechnicians = m_controller.getUsers(util::UserType::TECHNICIAN);
+	int bookingsSize = currentBookings.getSize();
+	util::Map<int, const ServiceBooking*> serviceBookingsMap;
+	util::Map<int, const User*> currentAvailableTechniciansMap;
+	if (listServiceBookings(currentBookings, bookingsSize, serviceBookingsMap))
+	{
+		const ServiceBooking* selectedService = selectPendingServiceBookings(serviceBookingsMap);
+		if (selectedService)
+		{
+			if (availableTechnicians.getSize() != 0)
+			{
+				listAvailableTechnicians(availableTechnicians, availableTechnicians.getSize(), currentAvailableTechniciansMap);
+				const User* selectedTechnician = selectTechnician(currentAvailableTechniciansMap);
+				if (selectedTechnician)
+				{
+					auto& servicesInBooking = selectedService->getServices();
+					for (int iterator = 0; iterator < servicesInBooking.getSize(); iterator++)
+					{
+						m_controller.createJobCard(selectedService->getId(), selectedTechnician->getId(), servicesInBooking.getValueAt(iterator)->getId());
+					}
+				}
+			}
+			else
+			{
+				std::cout << "No technicians are currently available.";
+			}
+		}
 	}
 
+}
+
+/*
+Function: selectInventoryItems (static helper)
+Description: Allows selection of inventory items by index for creating a service.
+Parameters:
+	- currentInventoryItems: util::Map<std::string, const InventoryItem*>&, available inventory items
+	- selectedInventoryItems: util::Vector<std::string>&, vector to store selected item IDs
+Returns:
+	- void
+*/
+static void selectInventoryItems(util::Map<std::string, const InventoryItem*>& currentInventoryItems, util::Vector<std::string>& selectedInventoryItems)
+{
+	bool doRun = true, hasInventoryItems = false;
+	util::Map<int, const InventoryItem*> currentInventoryMap;
+	int currentIndex = 1;
+	int choice;
+	if (currentInventoryItems.getSize() == 0)
+	{
+		std::cout << "Inventory empty.";
+	}
+	while (doRun)
+	{
+		bool hasInventoryItems = false;
+		int currentIndex = 1;
+		currentInventoryMap.clear();
+		std::cout << std::left
+			<< std::setw(6) << "Index"
+			<< std::setw(12) << "Item ID"
+			<< std::setw(20) << "Part Name"
+			<< std::setw(10) << "Price"
+			<< std::setw(10) << "Quantity"
+			<< std::endl;
+		for (int iterator = 0; iterator < currentInventoryItems.getSize(); iterator++)
+		{
+			const InventoryItem* currentInventoryItem = currentInventoryItems.getValueAt(iterator);
+			if (currentInventoryItem->getState() == util::State::INACTIVE)
+			{
+				continue;
+			}
+			std::cout << std::left
+				<< std::setw(6) << currentIndex
+				<< std::setw(12) << currentInventoryItem->getId()
+				<< std::setw(20) << currentInventoryItem->getPartName()
+				<< std::setw(10) << currentInventoryItem->getPrice()
+				<< std::setw(10) << currentInventoryItem->getQuantity()
+				<< std::endl;
+
+			hasInventoryItems = true;
+			currentInventoryMap.insert(currentIndex++, currentInventoryItem);
+		}
+		if (!hasInventoryItems)
+		{
+			std::cout << "No items present in the inventory." << std::endl;
+			doRun = false;
+			break;
+		}
+		std::cout << "Select the item (Index) or enter -1 to exit: ";
+		util::read(choice);
+
+		if (choice == -1)
+		{
+			doRun = false;
+		}
+		else if (currentInventoryMap.find(choice) != -1)
+		{
+			selectedInventoryItems.push_back(currentInventoryMap.getValueAt(choice)->getId());
+			std::cout << "Item added successfully." << std::endl;
+		}
+		else
+		{
+			std::cout << "Enter a valid integer." << std::endl;
+		}
+	}
+}
+
+/*
+Function: createService
+Description: Allows the admin to create a new service by selecting inventory items and specifying labor cost.
+Parameters:
+	- None
+Returns:
+	- void
+*/
 void AdminMenu::createService()
 {
+	util::clear();
+	std::string serviceName;
+	double labourCost;
+	std::cout << "Enter the service name: ";
+	util::read(serviceName);
+	util::Map<std::string, const InventoryItem*> currentInventoryItems = m_controller.getInventoryItems();
+	util::Vector<std::string> selectedInventoryItems;
+	selectInventoryItems(currentInventoryItems,selectedInventoryItems);
+	std::cout << "Enter the labour cost: ";
+	util::read(labourCost);
+    m_controller.createService(serviceName, selectedInventoryItems, labourCost);
+    std::cout << "Service created sucessfully.\n";
 }
 
+/*
+Function: selectServicesToRemove (static helper)
+Description: Allows selection of a service to remove by index.
+Parameters:
+	- currentServices: util::Map<std::string, const Service*>, available services
+Returns:
+	- std::string: ID of the selected service, or empty string if invalid
+*/
+static std::string selectServicesToRemove(util::Map<std::string, const Service*> currentServices)
+{
+    util::Map<int, const Service*> currentServicesMap;
+    bool hasServices = false;
+    int currentIndex = 1, choice;
+    std::cout << std::left
+        << std::setw(6) << "Index"
+        << std::setw(12) << "Service ID"
+        << std::setw(20) << "Name"
+        << std::setw(10) << "Labor Cost"
+        << std::endl;
+    for (int iterator = 0; iterator < currentServices.getSize(); iterator++)
+    {
+        const Service* currentService = currentServices.getValueAt(iterator);
+        if (currentService->getState() == util::State::INACTIVE)
+        {
+            continue;
+        }
+        std::cout << std::left
+            << std::setw(6) << currentIndex
+            << std::setw(12) << currentService->getId()
+            << std::setw(20) << currentService->getName()
+            << std::setw(10) << currentService->getLaborCost()
+            << std::endl;
+        hasServices = true;
+        currentServicesMap.insert(currentIndex++, currentService);
+    }
+    if (!hasServices)
+    {
+        std::cout << "No services currently available." << std::endl;
+        return "";
+    }
+    std::cout << "Enter your choice: ";
+    util::read(choice);
+    if (currentServicesMap.find(choice) != -1)
+    {
+        return currentServicesMap.getValueAt(currentServicesMap.find(choice))->getId();
+    }
+    else
+    {
+        std::cout << "Invalid choice." << std::endl;
+        return "";
+    }
+}
+
+/*
+Function: removeService
+Description: Allows the admin to remove an existing service by selecting from available services.
+Parameters:
+	- None
+Returns:
+	- void
+*/
 void AdminMenu::removeService()
 {
+	util::clear();
+	std::string selectedServiceID;
+	util::Map<std::string, const Service*> currentServices = m_controller.getServices();
+	selectedServiceID = selectServicesToRemove(currentServices);
+	if (selectedServiceID != "")
+	{
+		m_controller.removeService(selectedServiceID);
+		std::cout << "Service removed sucessfully.";
+	}
+	else
+	{
+		std::cout << "Failed  to remove service.";
+	}
 }
 
 void AdminMenu::addTechnician()
@@ -104,15 +442,6 @@ void AdminMenu::removeComboPackage()
 {
 }
 
-/*
-Function: viewNotifications
-Description: Displays notifications for the admin and allows deletion of notifications.
-Parameters:
-	- None
-Returns:
-	- void
-*/
 void AdminMenu::viewNotifications()
 {
-	viewAndDeleteNotification(m_controller);
 }

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

@@ -1,12 +1,3 @@
-/*
-File: AdminMenu.h
-Description: Declares the AdminMenu class which provides the administrative console menu in the Vehicle Service Management System.
-             Supports operations such as inventory management, job assignment, service creation/removal, technician management,
-             combo package handling, notification viewing, and account management functions like logout and password change.
-Author: Trenser
-Date: 19-May-2026
-*/
-
 #pragma once
 #include "Controller.h"
 

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

@@ -1,54 +1,25 @@
-/*
-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 "ComboPackage.h"
 #include "CustomerMenu.h"
 #include "InputHelper.h"
-#include "InventoryItem.h"
-#include "Map.h"
-#include "MenuHelper.h"
 #include "OutputHelper.h"
-#include "Service.h"
+#include "User.h"
-#include "Validator.h"
+#include "ServiceBooking.h"
-#include "Vector.h"
+#include "Enums.h"
-
-/*
-Function: showMenu
-Description: Displays the customer menu and handles user input until logout is selected.
-Parameter: None
-Return type: void
-*/
 
 void CustomerMenu::showMenu()
 {
-    while (true)
+	bool isMenuActive = true;
+	while (isMenuActive)
 	{
 		try
 		{
 			int choice;
 			util::clear();
-            std::cout << "Customer Menu"
+			std::cout << "" << std::endl;
-                << "\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))
 			{
-                break;
+				isMenuActive = false;
 			}
 		}
 		catch (const std::exception& e)
@@ -59,172 +30,80 @@ 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()
 {
-    changePasswordHelper(m_controller);
 }
 
-/*
-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: 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();
+void CustomerMenu::selectComboPackage()
-    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: selectComboPackage
+Function: viewServiceHistory
-Description: Allows the customer to select a combo package, provide vehicle details,
+Description: Displays the customer’s past service bookings in tabular format,
-             and book the package through the controller.
+             including booking ID, technician, vehicle details, discount percentage, and status.
-Parameter: None
+Parameters:
-Return type: void
+    - None
+Returns:
+    - 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()
 {
+	util::clear();
+	bool hasServiceHistory = false;
+	const User* currentUser = m_controller.getAuthenticatedUser();
+	std::string currentUserID = currentUser->getId();
+	util::Map<std::string, const ServiceBooking*> serviceBookingsByCurrentUser = m_controller.getServiceBookingsByUser(currentUserID);
+    if (serviceBookingsByCurrentUser.getSize() != 0)
+    {
+        std::cout << std::left
+            << std::setw(12) << "Booking ID"
+            << std::setw(20) << "Technician"
+            << std::setw(15) << "Vehicle Brand"
+            << std::setw(15) << "Vehicle Number"
+            << std::setw(15) << "Vehicle Model"
+            << std::setw(10) << "Discount %"
+            << std::setw(12) << "Status"
+            << std::endl;
+        for (int iterator = 0; iterator < serviceBookingsByCurrentUser.getSize(); iterator++)
+        {
+            const ServiceBooking* currentBooking = serviceBookingsByCurrentUser.getValueAt(iterator);
+            std::string technicianName = currentBooking->getAssignedTechnician() == nullptr
+                ? "Not Assigned"
+                : currentBooking->getAssignedTechnician()->getName();
+            std::cout << std::left
+                << std::setw(12) << currentBooking->getId()
+                << std::setw(20) << technicianName
+                << std::setw(15) << currentBooking->getVehicleBrand()
+                << std::setw(15) << currentBooking->getVehicleNumber()
+                << std::setw(15) << currentBooking->getVehicleModel()
+                << std::setw(10) << currentBooking->getDiscountPercentage()
+                << std::setw(12) << util::getServiceJobStatusString(currentBooking->getStatus())
+                << std::endl;
+            hasServiceHistory = true;
+        }
+    }
+    if (!hasServiceHistory)
+    {
+        std::cout << "No history available." << std::endl;
+    }
 }
 
 void CustomerMenu::completePayments()
@@ -235,34 +114,10 @@ void CustomerMenu::viewInvoices()
 {
 }
 
-/*
-Function: viewNotifications
-Description: Displays notifications for the customer and allows deletion of notifications.
-Parameters:
-    - None
-Returns:
-    - void
-*/
 void CustomerMenu::viewNotifications()
 {
-	viewAndDeleteNotification(m_controller);
 }
 
-
-/*
-Function: configureNotifications
-Description: Allows the customer to configure notification preferences for payment and service management.
-Parameters:
-    - None
-Returns:
-    - void
-*/
 void CustomerMenu::configureNotifications()
 {
-    bool paymentServiceNotifications = getNotificationPreference("Payment Management Service");
-    bool serviceManagementNotifications = getNotificationPreference("Service Management Service");
-    m_controller.configureNotifications(paymentServiceNotifications, serviceManagementNotifications);
-    util::clear();
-    std::cout << "Notification preferences updated successfully.\n";
-    util::pressEnter();
 }

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

@@ -1,13 +1,3 @@
-/*
-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

@@ -1,287 +0,0 @@
-/*
-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: 21-May-2026
-*/
-
-#pragma once
-#include <iomanip>
-#include <string>
-#include "Controller.h"
-#include "InputHelper.h"
-#include "Map.h"
-#include "Notification.h"
-#include "OutputHelper.h"
-#include "Vector.h"
-#include "Validator.h"
-#include "Service.h"
-#include "ComboPackage.h"
-#include "Utility.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;
-    }
-    util::Map<int, const Notification*> indexedNotifications;
-    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 index = 0; index < notifications.getSize(); index++)
-    {
-        const Notification* currentNotification = notifications[index];
-        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;
-            indexedNotifications.insert(currentIndex, currentNotification);
-            currentIndex++;
-        }
-    }
-    int selectedIndex;
-    std::cout << "Select notification: ";
-    util::read(selectedIndex);
-    if (!indexedNotifications.containsKey(selectedIndex))
-    {
-        std::cout << "Invalid selection." << std::endl;
-        return nullptr;
-    }
-    return indexedNotifications[selectedIndex];
-}
-
-/*
-Function: displayNotification
-Description: Displays detailed information about a single notification, including ID, title, timestamp, and message.
-Parameters:
-    - notification: Pointer to the Notification object to be displayed.
-Returns:
-    - void
-*/
-inline void displayNotification(const Notification* notification)
-{
-    util::clear();
-    if (!notification)
-    {
-        std::cout << "Notification not found." << std::endl;
-        return;
-    }
-    std::cout << "Notification Details" << std::endl;
-    std::cout << "ID        : " << notification->getId() << std::endl;
-    std::cout << "Title     : " << notification->getTitle() << std::endl;
-    std::cout << "Timestamp : " << notification->getCreatedAt().toString() << std::endl;
-    std::cout << "Message   : " << notification->getMessage() << std::endl;
-}
-
-/*
-Function: viewAndDeleteNotification
-Description: Allows the user to view a notification and then delete it from the system using the controller.
-Parameters:
-    - controller: Reference to the Controller object used to manage notifications.
-Returns:
-    - void
-*/
-inline void viewAndDeleteNotification(Controller& controller)
-{
-    util::clear();
-	auto notifications = controller.getNotifications();
-	const Notification* selectedNotification = selectNotification(notifications);
-	if (!selectedNotification)
-	{
-		std::cout << "Failed to display notification!";
-		util::pressEnter();
-		return;
-	}
-	displayNotification(selectedNotification);
-    controller.deleteNotification(selectedNotification->getId());
-    util::pressEnter();
-}
-
-/*
-Function: changePassword
-Description: Helper function to change password
-Parameter: controller: Reference to the Controller object used to manage notifications.
-Return type: void
-*/
-inline void changePasswordHelper(Controller& controller)
-{
-    std::string newPassword;
-    while (true)
-    {
-        util::clear();
-        std::cout << "Enter new password: ";
-        util::read(newPassword);
-        if (!util::isPasswordValid(newPassword))
-        {
-            std::cout << "Error: Password is not strong enough!\n";
-            util::pressEnter();
-            continue;
-        }
-        controller.changePassword(newPassword);
-        std::cout << "Password changed successfully\n";
-        util::pressEnter();
-        break;
-    }
-}
-
-/*
-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
-*/
-inline 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 = util::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: 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
-*/
-inline 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) << util::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: sendLowStockAlertsToAdmins (static helper)
-Description: Sends low stock alert notifications to all admin users for a given inventory item.
-Parameters:
-    - inventoryManagementService: InventoryManagementService&, service used to send notifications
-    - inventoryItem: const InventoryItem*, pointer to the low-stock inventory item
-    - adminUsers: const util::Vector<User*>&, list of admin users to notify
-Returns:
-    - None
-*/
-
-/*
-Function: getNotificationPreference (static helper)
-Description: Helper function to configure notification preferences for a specific service.
-Parameters:
-    - serviceName: Name of the service for which notifications are being configured.
-Returns:
-    - bool: True if notifications are enabled, False if disabled.
-*/
-inline bool getNotificationPreference(const std::string& serviceName)
-{
-    int choice;
-    while (true)
-    {
-        util::clear();
-        std::cout << "    Configure Notification Preferences\n";
-        std::cout << "\n" << serviceName << " Notifications\n";
-        std::cout << "1. Enable Notifications\n";
-        std::cout << "2. Disable Notifications\n";
-        std::cout << "Enter your choice: ";
-        util::read(choice);
-        if (choice == 1)
-        {
-            return true;
-        }
-        if (choice == 2)
-        {
-            return false;
-        }
-        std::cout << "\nInvalid choice. Please enter 1 or 2.\n";
-        util::pressEnter();
-    }
-}
-

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

@@ -1,26 +1,11 @@
-/*
+#include <iomanip>
-File: TechnicianMenu.cpp
-Description: Implements the TechnicianMenu class which provides the technician’s console interface
-			 in the Vehicle Service Management System. Handles menu display, user input, and
-			 technician-specific operations such as completing jobs and viewing notifications.
-Author: Trenser
-Date: 19-May-2026
-*/
-
 #include "TechnicianMenu.h"
 #include "InputHelper.h"
 #include "OutputHelper.h"
-#include "MenuHelper.h"
+#include "JobCard.h"
+#include "Enums.h"
+#include "Service.h"
 
-/*
-Function: showMenu
-Description: Displays the technician menu in a loop until the user chooses to logout.
-			 Handles exceptions and ensures smooth user interaction.
-Parameters:
-	- None
-Returns:
-	- void
-*/
 void TechnicianMenu::showMenu()
 {
 	bool isMenuActive = true;
@@ -50,19 +35,88 @@ bool TechnicianMenu::handleOperation(int choice)
 	return false;
 }
 
-void TechnicianMenu::completeJob()
+/*
+Function: selectJobCardToComplete (static helper)
+Description: Lists all incomplete job cards assigned to the technician and allows selection by index.
+Parameters:
+    - assignedJobCards: util::Map<std::string, const JobCard*>&, job cards assigned to the technician
+    - incompleteJobCards: util::Map<int, const JobCard*>&, map of incomplete job cards indexed for selection
+Returns:
+    - std::string: ID of the selected job card, or empty string if none selected
+*/
+static std::string selectJobCardToComplete(util::Map<std::string, const JobCard*>& assignedJobCards, util::Map<int, const JobCard*>& incompleteJobCards)
 {
+    int currentIndex = 1;
+    int choice;
+    bool hasIncompleteJobCard = false;
+    std::cout << std::left
+        << std::setw(6) << "Index"
+        << std::setw(12) << "BookingID"
+        << std::setw(12) << "JobID"
+        << std::setw(20) << "ServiceName"
+        << std::setw(12) << "ServiceID"
+        << std::endl;
+    for (int iterator = 0; iterator < assignedJobCards.getSize(); iterator++)
+    {
+        const JobCard* currentJobCard = assignedJobCards.getValueAt(iterator);
+        if (currentJobCard && (currentJobCard->getStatus() == util::ServiceJobStatus::STARTED))
+        {
+            std::cout << std::left << std::setw(6) << currentIndex
+                << std::setw(12) << currentJobCard->getBookingId()
+                << std::setw(12) << currentJobCard->getId()
+                << std::setw(20) << currentJobCard->getService()->getName()
+                << std::setw(12) << currentJobCard->getServiceId()
+                << std::endl;
+            hasIncompleteJobCard = true;
+            incompleteJobCards.insert(currentIndex++, currentJobCard);
+        }
+    }
+    if (!hasIncompleteJobCard)
+    {
+        std::cout << "No pending jobs are present.\n";
+        return "";
+    }
+    std::cout << "Select the Job Card to complete (Index): ";
+    util::read(choice);
+    int selectedJobCardIndex = incompleteJobCards.find(choice);
+    if (selectedJobCardIndex != -1)
+    {
+        const JobCard* selectedJobCard = incompleteJobCards.getValueAt(selectedJobCardIndex);
+        return selectedJobCard->getId();
+    }
+    else
+    {
+        std::cout << "Invalid choice.\n";
+        return "";
+    }
 }
 
 /*
-Function: viewNotifications
+Function: completeJob
-Description: Displays notifications for the technician and allows deletion of notifications.
+Description: Allows the technician to mark a selected job card as completed.
+             Validates selection and updates job status through the controller.
 Parameters:
     - None
 Returns:
     - void
 */
+void TechnicianMenu::completeJob()
+{
+	util::Map<std::string, const JobCard*> assignedJobCards = m_controller.getJobCardsByUser();
+	util::Map<int, const JobCard*> incompleteJobCards;
+	std::cout << "Jobs to be completed.\n";
+	std::string selectedJobID = selectJobCardToComplete(assignedJobCards, incompleteJobCards);
+	if (selectedJobID == "")
+	{
+		std::cout << "Failed to complete the job.\n";
+	}
+	else
+	{
+		m_controller.completeJob(selectedJobID);
+		std::cout << "Job marked as completed.\n";
+	}
+}
+
 void TechnicianMenu::viewNotifications()
 {
-	viewAndDeleteNotification(m_controller);
 }

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

@@ -1,11 +1,3 @@
-/*
-File: TechnicianMenu.h
-Description: Declares the TechnicianMenu class which provides the technician-facing console menu in the Vehicle Service Management System.
-             Supports operations such as viewing assigned jobs, completing jobs, and managing notifications.
-Author: Trenser
-Date: 19-May-2026
-*/
-
 #pragma once
 #include "Controller.h"
 

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

@@ -1,30 +1,9 @@
-/*
-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();
-	m_controller.runSystemChecks();
 	bool isMenuActive = true;
 	while (isMenuActive)
 	{
@@ -45,15 +24,8 @@ 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)
@@ -74,90 +46,12 @@ 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,12 +1,3 @@
-/*
-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"