Add documentation headers across system modules

<UserStory> PAY001: Generate Invoice </UserStory>

<Changes>
    1. Added Utility.h to project configuration for supporting invoice generation utilities.
    2. Updated Invoice model to use string-based keys for parts mapping instead of integer keys.
    3. Implemented PaymentManagementService::generateInvoice to aggregate labour cost, parts cost, and apply discounts.
    4. Integrated invoice creation with Factory to instantiate Invoice objects and persist them into datastore.
    5. Enhanced Enums with PaymentMode::NOTSET to handle default invoice state.
</Changes>

<Test>

 Acceptance Criteria:
 1. Invoice auto-generates for each service booking once jobs are completed.
 2. Invoice shows a clear breakdown of charges including labour cost, parts cost, discount, and total amount.

 Precondition:
  1. Service booking exists with at least one service and required inventory items.
  2. Datastore is available for storing invoices.
  3. Payment mode and status enums are properly configured.

 Steps:
  1. Complete all jobs in a service booking.
    - Verify that PaymentManagementService::generateInvoice is triggered.
  2. Check datastore for newly created invoice.
    - Verify that invoice contains booking ID, labour cost, parts cost, discount, and total amount.
  3. Inspect invoice details.
    - Verify that breakdown of charges is accurate and discount is applied correctly.
  4. Confirm invoice status.
    - Verify that invoice is created with PaymentMode::NOTSET and PaymentStatus::PENDING.
</Test>

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

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

@@ -171,7 +171,6 @@
     <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\InputHelper.h" />
     <ClInclude Include="utilities\Map.h" />
@@ -182,7 +181,6 @@
     <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,5 +233,8 @@
     <ClInclude Include="models\ComboPackage.h">
       <Filter>Header Files\Models</Filter>
     </ClInclude>
+    <ClInclude Include="utilities\Utility.h">
+      <Filter>Header Files\Utilities</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

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

@@ -1,95 +1,35 @@
-/*
-File: Controller.cpp
-Description: Implementation file containing the method definitions of the
-             Controller class, including authentication, user creation,
-             service purchasing, and system checks.
-Author: Trenser
-Date:19-May-2026
-*/
-#include <stdexcept>
 #include "Controller.h"
-#include "Enums.h"
 #include "User.h"
+#include "Invoice.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);
 }
 
-/*
-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)
+void Controller::createCustomer(const std::string& username, 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& password, const std::string& email, const std::string& phone)
 {
 }
 
-/*
-Function: updateUserDetails
-Description: Updates the email and phone details of the currently authenticated user.
-Parameter: const std::string& email - new email address
-           const std::string& phone - new phone number
-Return type: void
-*/
 void Controller::updateUserDetails(const std::string& email, const std::string& phone)
 {
-    User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
-    if (authenticatedUser == nullptr)
-    {
-        throw std::runtime_error("No user currently logged in!");
-    }
-    m_userManagementService.updateUserDetails(authenticatedUser->getId(), email, phone);
 }
 
 util::Map<std::string, const Service*> Controller::getServices()
@@ -102,32 +42,12 @@ 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()
@@ -201,13 +121,40 @@ void Controller::removeComboPackage(const std::string& comboPackageID)
 {
 }
 
+/*
+Function: getInvoicesByUser
+Description: Retrieves all invoices associated with the currently authenticated user.
+             Converts them into a read-only map before returning.
+Parameters:
+    - None
+Returns:
+    - util::Map<std::string, const Invoice*> containing the user’s invoices
+*/
 util::Map<std::string, const Invoice*> Controller::getInvoicesByUser()
 {
-    return util::Map<std::string, const Invoice*>();
+    User* currentUser = m_authenticationManagementService.getAuthenticatedUser();
+    util::Map<std::string, Invoice*> currentUserInvoices =  m_paymentManagementService.getInvoices(currentUser->getId());
+    util::Map<std::string, const Invoice*> userInvoicesReadOnly;
+    for (int iterator = 0; iterator < currentUserInvoices.getSize(); iterator++)
+    {
+        Invoice* currentInvoice = currentUserInvoices.getValueAt(iterator);
+        userInvoicesReadOnly.insert(currentInvoice->getId(), currentInvoice);
+    }
+    return userInvoicesReadOnly;
 }
 
+/*
+Function: completePayment
+Description: Completes payment for a specific invoice using the given payment mode.
+Parameters:
+    - invoiceID: std::string, ID of the invoice to be paid
+    - paymentMode: util::PaymentMode, mode of payment (e.g., ONLINE, OFFLINE)
+Returns:
+    - void
+*/
 void Controller::completePayment(const std::string& invoiceID, util::PaymentMode paymentMode)
 {
+    m_paymentManagementService.completePayment(invoiceID, paymentMode);
 }
 
 util::Vector<const Notification*> Controller::getNotifications()
@@ -223,14 +170,6 @@ void Controller::configureNotifications(const std::string& userID, bool paymentN
 {
 }
 
-/*
-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();
-}
-
+}

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

@@ -1,18 +1,9 @@
-/*
-File: Controller.h
-Description: Header file declaring the Controller class, which coordinates
-             authentication, user management, service management, inventory,
-             and notifications across the Vehicle Service System.
-Author: Trenser
-Date:19-May-2026
-*/
 #pragma once
 #include "Map.h"
 #include <string>
 #include "Enums.h"
+#include "PaymentManagementService.h"
 #include "AuthenticationManagementService.h"
-#include "UserManagementService.h"
-#include "ServiceManagementService.h"
 
 class Service;
 class ComboPackage;
@@ -27,13 +18,12 @@ class Controller
 {
 private:
     AuthenticationManagementService m_authenticationManagementService;
-    UserManagementService m_userManagementService;
-    ServiceManagementService m_serviceManagementService;
+    PaymentManagementService m_paymentManagementService;
 public:
     bool login(const std::string& username, const std::string& password);
     void logout();
     void changePassword(const std::string& newPassword);
-    void createCustomer(const std::string& username, const std::string& 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& password, const std::string& email, const std::string& phone);
     void updateUserDetails(const std::string& email, const std::string& phone);

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

@@ -16,7 +16,8 @@ Invoice::Invoice(
     const std::string& bookingId,
     ServiceBooking* booking,
     const util::Timestamp& invoiceDate, 
-    double laborCost, const util::Map<int,
+    double laborCost, 
+    const util::Map<std::string,
     InventoryItem*>& parts,
     double partsCost,
     double discountPercentage, 
@@ -63,7 +64,7 @@ double Invoice::getLaborCost() const
     return m_laborCost;
 }
 
-const util::Map<int, InventoryItem*>& Invoice::getParts() const
+const util::Map<std::string, InventoryItem*>& Invoice::getParts() const
 {
     return m_parts;
 }
@@ -123,7 +124,7 @@ void Invoice::setLaborCost(double laborCost)
     m_laborCost = laborCost;
 }
 
-void Invoice::setParts(const util::Map<int, InventoryItem*>& parts)
+void Invoice::setParts(const util::Map<std::string, InventoryItem*>& parts)
 {
     m_parts = parts;
 }

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

@@ -16,7 +16,7 @@ private:
     ServiceBooking* m_booking;
     util::Timestamp m_invoiceDate;
     double m_laborCost;
-    util::Map<int, InventoryItem*> m_parts;
+    util::Map<std::string, InventoryItem*> m_parts;
     double m_partsCost;
     double m_discountPercentage;
     double m_totalAmount;
@@ -30,8 +30,8 @@ public:
         const std::string& bookingId,
         ServiceBooking* booking,
         const util::Timestamp& invoiceDate, 
-        double laborCost, const util::Map<int,
-        InventoryItem*>& parts,
+        double laborCost, 
+        const util::Map<std::string,InventoryItem*>& parts,
         double partsCost,
         double discountPercentage, 
         double totalAmount, 
@@ -44,7 +44,7 @@ public:
     ServiceBooking* getBooking() const;
     const util::Timestamp& getInvoiceDate() const;
     double getLaborCost() 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;
@@ -56,7 +56,7 @@ public:
     void setBooking(ServiceBooking* booking);
     void setInvoiceDate(const util::Timestamp& invoiceDate);
     void setLaborCost(double laborCost);
-    void setParts(const util::Map<int, InventoryItem*>& parts);
+    void setParts(const util::Map<std::string, InventoryItem*>& parts);
     void setPartsCost(double partsCost);
     void setDiscountPercentage(double discountPercentage);
     void setTotalAmount(double totalAmount);

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

@@ -7,7 +7,7 @@ JobCard::JobCard()
     m_booking(nullptr),
     m_service(nullptr),
     m_technician(nullptr),
-    m_status(ServiceJobStatus()) {}
+    m_status(util::ServiceJobStatus()) {}
 
 JobCard::JobCard(const std::string& bookingId,
     ServiceBooking* booking,
@@ -16,7 +16,7 @@ JobCard::JobCard(const std::string& bookingId,
     const std::string& technicianId,
     User* technician,
     const util::Timestamp& assignedDate,
-    ServiceJobStatus status,
+    util::ServiceJobStatus status,
     const util::Timestamp& completionDate
 )
     : m_id("JC" + std::to_string(++m_uid)),
@@ -70,7 +70,7 @@ const util::Timestamp& JobCard::getAssignedDate() const
     return m_assignedDate;
 }
 
-ServiceJobStatus JobCard::getStatus() const
+util::ServiceJobStatus JobCard::getStatus() const
 {
     return m_status;
 }
@@ -120,7 +120,7 @@ void JobCard::setAssignedDate(const util::Timestamp& assignedDate)
     m_assignedDate = assignedDate;
 }
 
-void JobCard::setStatus(ServiceJobStatus status)
+void JobCard::setStatus(util::ServiceJobStatus status)
 {
     m_status = status;
 }

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

@@ -1,12 +1,12 @@
 #pragma once
 #include <string>
+#include "Enums.h"
 #include "Timestamp.h"
 
 class ServiceBooking;
 class Service;
 class User;
 
-enum class ServiceJobStatus : int;
 
 class JobCard
 {
@@ -20,7 +20,7 @@ private:
     std::string m_technicianId;
     User* m_technician;
     util::Timestamp m_assignedDate;
-    ServiceJobStatus m_status;
+    util::ServiceJobStatus m_status;
     util::Timestamp m_completionDate;
 
 public:
@@ -32,7 +32,7 @@ public:
         const std::string& technicianId, 
         User* technician, 
         const util::Timestamp& assignedDate, 
-        ServiceJobStatus status,
+        util::ServiceJobStatus status,
         const util::Timestamp& completionDate
     );
     const std::string& getId() const;
@@ -43,7 +43,7 @@ public:
     const std::string& getTechnicianId() const;
     User* getTechnician() const;
     const util::Timestamp& getAssignedDate() const;
-    ServiceJobStatus getStatus() const;
+    util::ServiceJobStatus getStatus() const;
     const util::Timestamp& getCompletionDate() const;
     void setId(const std::string& id);
     void setBookingId(const std::string& bookingId);
@@ -53,6 +53,6 @@ public:
     void setTechnicianId(const std::string& technicianId);
     void setTechnician(User* technician);
     void setAssignedDate(const util::Timestamp& assignedDate);
-    void setStatus(ServiceJobStatus status);
+    void setStatus(util::ServiceJobStatus status);
     void setCompletionDate(const util::Timestamp& completionDate);
 };

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

@@ -1,43 +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 "ServiceBooking.h"
 
 int ServiceBooking::m_uid = 0;
 
-/*
-Function: ServiceBooking
-Description: Default constructor that initializes a new service booking
-             with a unique ID, no customer or technician, and zero discount.
-Parameter: None
-Return type: Constructor
-*/
 ServiceBooking::ServiceBooking()
     : m_id("SRV" + std::to_string(++m_uid)),
     m_customer(nullptr),
-    m_assignedTechnician(nullptr),
     m_discountPercentage(0.0) {}
 
-/*
-Function: ServiceBooking
-Description: Parameterized constructor that initializes a service booking
-             with customer, vehicle, services, and discount details.
-Parameter: util::ServiceJobStatus status - current booking status
-           const util::Map<std::string, Service*>& services - map of services
-           const std::string& customerId - ID of the customer
-           User* customer - pointer to the customer object
-           const std::string& vehicleNumber - vehicle registration number
-           const std::string& vehicleBrand - brand of the vehicle
-           const std::string& vehicleModel - model of the vehicle
-           double discountPercentage - discount applied to the booking
-Return type: Constructor
-*/
 ServiceBooking::ServiceBooking(
+    const std::string& id,
     util::ServiceJobStatus status,
     const util::Map<std::string,
     Service*>& services,
@@ -46,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)),
@@ -56,248 +29,117 @@ ServiceBooking::ServiceBooking(
     m_vehicleNumber(vehicleNumber),
     m_vehicleBrand(vehicleBrand),
     m_vehicleModel(vehicleModel),
-    m_assignedTechnicianId(""),
-    m_assignedTechnician(nullptr),
+    m_assignedTechnicianId(assignedTechnicianId),
+    m_assignedTechnician(assignedTechnician),
     m_discountPercentage(discountPercentage)
 {
 }
 
-/*
-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: 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;
 }
 
-/*
-Function: getAssignedTechnician
-Description: Retrieves the technician object assigned to the booking.
-Parameter: None
-Return type: User*
-*/
-User* ServiceBooking::getAssignedTechnician() const
+const 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;
 }
 
-/*
-Function: setCustomerId
-Description: Sets the customer ID for the booking.
-Parameter: const std::string& customerId - new customer ID
-Return type: void
-*/
 void ServiceBooking::setCustomerId(const std::string& customerId)
 {
     m_customerId = customerId;
 }
 
-/*
-Function: setCustomer
-Description: Sets the customer object for the booking.
-Parameter: User* customer - pointer to the customer object
-Return type: void
-*/
 void ServiceBooking::setCustomer(User* customer)
 {
     m_customer = customer;
 }
 
-/*
-Function: setVehicleNumber
-Description: Sets the vehicle registration number for the booking.
-Parameter: const std::string& vehicleNumber - new vehicle number
-Return type: void
-*/
 void ServiceBooking::setVehicleNumber(const std::string& vehicleNumber)
 {
     m_vehicleNumber = vehicleNumber;
 }
 
-/*
-Function: setVehicleBrand
-Description: Sets the brand of the vehicle for the booking.
-Parameter: const std::string& vehicleBrand - new vehicle brand
-Return type: void
-*/
 void ServiceBooking::setVehicleBrand(const std::string& vehicleBrand)
 {
     m_vehicleBrand = vehicleBrand;
 }
 
-/*
-Function: setVehicleModel
-Description: Sets the model of the vehicle for the booking.
-Parameter: const std::string& vehicleModel - new vehicle model
-Return type: void
-*/
 void ServiceBooking::setVehicleModel(const std::string& vehicleModel)
 {
     m_vehicleModel = vehicleModel;
 }
 
-/*
-Function: setAssignedTechnicianId
-Description: Sets the ID of the technician assigned to the booking.
-Parameter: const std::string& assignedTechnicianId - new technician ID
-Return type: void
-*/
 void ServiceBooking::setAssignedTechnicianId(const std::string& assignedTechnicianId)
 {
     m_assignedTechnicianId = assignedTechnicianId;
 }
 
-/*
-Function: setAssignedTechnician
-Description: Sets the technician object assigned to the booking.
-Parameter: User* assignedTechnician - pointer to the technician object
-Return type: void
-*/
-void ServiceBooking::setAssignedTechnician(User* assignedTechnician)
+void ServiceBooking::setAssignedTechnician(const 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;

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

@@ -1,11 +1,3 @@
-/*
-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"
@@ -27,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,
@@ -40,6 +33,8 @@ public:
         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;
@@ -51,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);
@@ -62,6 +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);
 };

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/PaymentManagementService.cpp

@@ -1 +1,135 @@
 #include "PaymentManagementService.h"
+#include "ServiceBooking.h"
+#include "Service.h"
+#include "InventoryItem.h"
+#include "Utility.h"
+#include "Factory.h"
+#include "Timestamp.h"
+#include "Invoice.h"
+#include "JobCard.h"
+#include "Enums.h"
+
+/*
+Function: createInventoryItemsMap (static helper)
+Description: Builds a map of inventory items required for a given service and adds them to the booking’s inventory map.
+Parameters:
+	- completeInventoryItemMapOfBooking: util::Map<std::string, InventoryItem*>&, map to store inventory items for the booking
+	- currentService: const Service*, pointer to the current service
+Returns:
+	- void
+*/
+static void createInventoryItemsMap(util::Map<std::string, InventoryItem*>& completeInventoryItemMapOfBooking, const Service* currentService)
+{
+	auto& currentRequiredInventoryItems = currentService->getRequiredInventoryItems();
+	for (int iterator = 0; iterator < currentRequiredInventoryItems.getSize(); iterator++)
+	{
+		auto& currentRequiredInventoryItem = currentRequiredInventoryItems.getValueAt(iterator);
+		completeInventoryItemMapOfBooking.insert(currentRequiredInventoryItem->getId(), currentRequiredInventoryItem);
+	}
+}
+
+/*
+Function: generateInvoice
+Description: Generates an invoice for a completed service booking.
+			 Validates that all job cards are completed, calculates labor and parts cost, applies discount,
+			 and stores the invoice in the datastore.
+Parameters:
+	- booking: ServiceBooking*, pointer to the service booking
+Returns:
+	- void
+Throws:
+	- std::runtime_error if booking is null or job cards are incomplete
+*/
+void PaymentManagementService::generateInvoice(ServiceBooking* booking)
+{
+	if (!booking)
+	{
+		throw std::runtime_error("Invoice generation failed: booking is null.");
+	}
+	double totalLabourCost = 0, totalPartsCost = 0, totalServiceCost = 0;
+	double discountPercentage = booking->getDiscountPercentage();
+	std::string bookingID = booking->getId();
+	util::Map<std::string, Service*> servicesInTheBookedService = booking->getServices();
+	util::Map<std::string, InventoryItem*> completeInventoryItemMapOfBooking;
+	util::Map<std::string, JobCard*> currentJobCards = m_dataStore.getJobCards();
+	for (int iterator = 0; iterator < currentJobCards.getSize(); iterator++)
+	{
+		JobCard* currentJobCard = currentJobCards.getValueAt(iterator);
+		if (currentJobCard->getBookingId() == bookingID && currentJobCard->getStatus() != util::ServiceJobStatus::COMPLETED)
+		{
+			throw std::runtime_error("Invoice generation failed: not all job cards are completed for booking '" + bookingID + "'.");
+		}
+	}
+	for (int iterator = 0; iterator < servicesInTheBookedService.getSize(); iterator++)
+	{
+		Service* currentService = servicesInTheBookedService.getValueAt(iterator);
+		if (currentService)
+		{
+			createInventoryItemsMap(completeInventoryItemMapOfBooking, currentService);
+			totalLabourCost += currentService->getLaborCost();
+			totalPartsCost += calculatePartsCost(currentService);
+		}
+	}
+	totalServiceCost = totalLabourCost + totalPartsCost;
+	totalServiceCost -= (totalServiceCost * (discountPercentage / 100));
+	Invoice* invoice = Factory::getObject<Invoice>(bookingID, booking, util::Timestamp(), totalLabourCost, completeInventoryItemMapOfBooking, totalPartsCost, discountPercentage, totalServiceCost, util::Timestamp(), util::PaymentMode::NOTSET, util::PaymentStatus::PENDING);
+	util::Map<std::string, Invoice*>& currentInvoices = m_dataStore.getInvoices();
+	currentInvoices.insert(invoice->getId(), invoice);
+}
+
+/*
+Function: getInvoices
+Description: Retrieves all invoices associated with a specific customer.
+Parameters:
+	- customerID: std::string, ID of the customer
+Returns:
+	- util::Map<std::string, Invoice*> containing the customer’s invoices
+*/
+util::Map<std::string, Invoice*> PaymentManagementService::getInvoices(const std::string& customerID)
+{
+	util::Map<std::string, Invoice*>& currentInvoices = m_dataStore.getInvoices();
+	util::Map<std::string, Invoice*> currentUserInvoices;
+	for (int iterator = 0; iterator < currentInvoices.getSize(); iterator++)
+	{
+		Invoice* currentInvoice = currentInvoices.getValueAt(iterator);
+		if (currentInvoice->getBooking()->getCustomerId() == customerID)
+		{
+			currentUserInvoices.insert(currentInvoice->getId(), currentInvoice);
+		}
+	}
+	return currentUserInvoices;
+}
+
+/*
+Function: completePayment
+Description: Completes payment for a specific invoice. Updates payment method, date, and status,
+			 then sends a notification to the customer.
+Parameters:
+	- invoiceID: std::string, ID of the invoice
+	- paymentMode: util::PaymentMode, mode of payment (e.g., ONLINE, OFFLINE)
+Returns:
+	- void
+Throws:
+	- std::runtime_error if the invoice ID is invalid
+*/
+void PaymentManagementService::completePayment(const std::string& invoiceID, util::PaymentMode paymentMode)
+{
+	auto& currentInvoices = m_dataStore.getInvoices();
+	int invoiceIndex = currentInvoices.find(invoiceID);
+	if (invoiceIndex != -1)
+	{
+		Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
+		User* currentUser = invoice->getBooking()->getCustomer();
+		invoice->setPaymentMethod(paymentMode);
+		invoice->setPaymentDate(util::Timestamp());
+		invoice->setStatus(util::PaymentStatus::COMPLETED);
+		std::string title, message;
+		title = "Payment successful";
+		message = "Payment successful for invoice ID " + invoiceID;
+		sendNotification(currentUser, title, message);
+	}
+	else
+	{
+		throw std::runtime_error("Payment failed: invalid invoice ID.");
+	}
+}

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

@@ -1,98 +1 @@
-/*
-File: ServiceManagementService.cpp
-Description: Implementation file containing the method definitions of the
-			 ServiceManagementService class, including service and combo package
-			 purchasing logic, booking creation, and notification handling.
-Author: Trenser
-Date:19-May-2026
-*/
-#include <stdexcept>
 #include "ServiceManagementService.h"
-#include "AuthenticationManagementService.h"
-#include "Service.h"
-#include "ServiceBooking.h"
-#include "ComboPackage.h"
-#include "Factory.h"
-
-/*
-Function: purchaseService
-Description: Creates a new service booking for the authenticated user. Validates
-			 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;
-	sendNotification(authenticatedUser,
-		"Service Booking succeeded",
-		"Your service booking has been successfully placed with ID " + serviceBooking->getId());
-}
-
-/*
-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;
-	sendNotification(authenticatedUser,
-		"Combo Package Service Booking succeeded",
-		"Your service booking for the combo package has been successfully placed with ID " + serviceBooking->getId());
-}

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"

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

@@ -1,112 +1 @@
-/*
-File: UserManagementService.cpp
-Description: Implementation file containing the method definitions of the
-			 UserManagementService class, including user creation, updates,
-			 and ensuring an admin account exists.
-Author: Trenser
-Date:19-May-2026
-*/
-#include <stdexcept>
-#include "User.h"
-#include "Enums.h"
-#include "Config.h"
 #include "UserManagementService.h"
-#include "ServiceManagementService.h"
-#include "PaymentManagementService.h"
-#include "InventoryManagementService.h"
-#include "Factory.h"
-
-/*
-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();
-	int usersMapSize = usersMap.getSize();
-	bool isAdminFound = false;
-	for (int index = 0; index < usersMapSize; index++)
-	{
-		User* user = usersMap.getValueAt(index);
-		if (user && user->getUserType() == util::UserType::ADMIN)
-		{
-			isAdminFound = true;
-			break;
-		}
-	}
-	if (!isAdminFound)
-	{
-		createUser(
-			config::admin::DEFAULT_ADMIN_USERNAME,
-			config::admin::DEFAULT_ADMIN_NAME,
-			config::admin::DEFAULT_ADMIN_PASSWORD,
-			config::admin::DEFAULT_ADMIN_EMAIL,
-			config::admin::DEFAULT_ADMIN_PHONE, 
-			util::UserType::ADMIN);
-	}
-}
-
-/*
-Function: 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;
-	PaymentManagementService paymentManagementService;
-	ServiceManagementService serviceManagementService;
-	auto& usersMap = m_dataStore.getUsers();
-	int index = usersMap.findIf(
-		[&](const std::string&, User* user)
-		{
-			return user->getUserName() == username;
-		}
-	);
-	if (index != -1)
-	{
-		throw std::runtime_error("Username already exists");
-	}
-	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);
-	}
-}
-
-/*
-Function: updateUserDetails
-Description: Updates the email and phone details of an existing user.
-			 Throws an exception if the user does not exist.
-Parameter: const std::string& userID - ID of the user to update
-		   const std::string& email - new email address
-		   const std::string& phone - new phone number
-Return type: void
-*/
-void UserManagementService::updateUserDetails(const std::string& userID, const std::string& email, const std::string& phone)
-{
-	auto& usersMap = m_dataStore.getUsers();
-	int index = usersMap.find(userID);
-	if (index == -1)
-	{
-		throw std::runtime_error("User does not exist!");
-	}
-	User* user = usersMap.getValueAt(index);
-	user->setEmail(email);
-	user->setPhone(phone);
-}

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

@@ -1,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,5 +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();
 };

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

@@ -1,21 +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:19-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";
-	}
-}

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

@@ -13,7 +13,8 @@ namespace util
 	enum class PaymentMode
 	{
 		ONLINE,
-		OFFLINE
+		OFFLINE,
+        NOTSET
 	};
 
 	enum class PaymentStatus
@@ -73,6 +74,8 @@ namespace util
             return "ONLINE";
         case PaymentMode::OFFLINE:
             return "OFFLINE";
+        case PaymentMode::NOTSET:
+            return "NOTSET";
         }
         throw std::invalid_argument("Invalid PaymentMode");
     }

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

@@ -1,21 +1,7 @@
-/*
-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 "Service.h"
 #include "InventoryItem.h"
 
-/*
-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;
@@ -26,24 +12,4 @@ inline double calculatePartsCost(const Service* service)
         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;
-}
+}

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

@@ -1,347 +1,260 @@
-/*
-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 <iostream>
 #include "CustomerMenu.h"
-#include "Service.h"
-#include "InventoryItem.h"
-#include "ComboPackage.h"
-#include "Service.h"
 #include "InputHelper.h"
 #include "OutputHelper.h"
-#include "Validator.h"
-#include "Vector.h"
-#include "Utility.h"
-#include "Map.h"
+#include "Invoice.h"
+#include "Enums.h"
+#include "ServiceBooking.h"
+#include "User.h"
+#include "Timestamp.h"
+#include "Service.h"
+#include "InventoryItem.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)
-    {
-        try
-        {
-            int choice;
-            util::clear();
-            std::cout << "Customer Menu"
-                << "\n1. Select a service"
-                << "\n2. Select a combo package"
-                << "\n3. Update Profile"
-                << "\n4. Change Password"
-                << "\n5. View Service History"
-                << "\n6. Complete Payments"
-                << "\n7. View Invoices"
-                << "\n8. View Notifications"
-                << "\n9. Configure Notifications"
-                << "\n10. Logout"
-                << "\nEnter a choice: ";
-            util::read(choice);
-            if (!handleOperation(choice))
-            {
-                break;
-            }
-        }
-        catch (const std::exception& e)
-        {
-            std::cout << "Exception: " << e.what() << std::endl;
-            util::pressEnter();
-        }
-    }
+	bool isMenuActive = true;
+	while (isMenuActive)
+	{
+		try
+		{
+			int choice;
+			util::clear();
+			std::cout << "" << std::endl;
+			util::read(choice);
+			if (!handleOperation(choice))
+			{
+				isMenuActive = false;
+			}
+		}
+		catch (const std::exception& e)
+		{
+			std::cout << "Exception: " << e.what() << std::endl;
+			util::pressEnter();
+		}
+	}
 }
 
-/*
-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;
+	return false;
 }
 
-/*
-Function: logout
-Description: Logs out the currently authenticated customer user.
-Parameter: None
-Return type: void
-*/
 void CustomerMenu::logout()
 {
-	m_controller.logout();
 }
 
-/*
-Function: changePassword
-Description: Allows the customer to change their password after validation.
-Parameter: None
-Return type: void
-*/
 void CustomerMenu::changePassword()
 {
-	std::string newPassword;
-	util::clear();
-	std::cout << "Enter new password: ";
-	util::read(newPassword);
-	m_controller.changePassword(newPassword);
-	if (!util::isPasswordValid(newPassword))
-	{
-		std::cout << "Error: Password is not strong enough!";
-		util::pressEnter();
-		return;
-	}
-	std::cout << "Password changed successfully";
-	util::pressEnter();
 }
 
-/*
-Function: updateDetails
-Description: Allows the customer to update their email and phone number after validation.
-Parameter: None
-Return type: void
-*/
 void CustomerMenu::updateDetails()
 {
-	std::string email, phone;
-	util::clear();
-	std::cout << "Enter new email: ";
-	util::read(email);
-	if (!util::isEmailValid(email))
-	{
-		std::cout << "Error: Email is invalid!";
-		util::pressEnter();
-		return;
-	}
-	std::cout << "Enter new phone: ";
-	util::read(phone);
-	if (!util::isPhoneNumberValid(phone))
-	{
-		std::cout << "Error: Phone number is invalid!";
-		util::pressEnter();
-		return;
-	}
-	m_controller.updateUserDetails(email, phone);
-	std::cout << "Profile details updated successfully";
-	util::pressEnter();
 }
 
-/*
-Function: selectServiceFromServices
-Description: Displays active services and allows the customer to select one by index.
-Parameter: const util::Map<std::string, const Service*>& services - list of services
-Return type: const Service* - selected service
-*/
-static const Service* selectServiceFromServices(const util::Map<std::string, const Service*>& services)
-{
-    util::Map<int, const Service*> activeServicesMap;
-    int currentIndex = 1;
-    int userInputIndex;
-    std::cout << std::left
-        << std::setw(10) << "Index"
-        << std::setw(15) << "Service ID"
-        << std::setw(25) << "Service Name"
-        << std::setw(15) << "Estimated Cost"
-        << std::endl;
-    for (int index = 0; index < services.getSize(); index++)
-    {
-        const Service* currentService = services.getValueAt(index);
-        if (currentService->getState() != util::State::ACTIVE)
-        {
-            continue;
-        }
-        activeServicesMap.insert(currentIndex, currentService);
-        double partsCost = calculatePartsCost(currentService);
-        std::cout << std::left
-            << std::setw(10) << currentIndex
-            << std::setw(15) << currentService->getId()
-            << std::setw(25) << currentService->getName()
-            << std::setw(15) << (currentService->getLaborCost() + partsCost)
-            << std::endl;
-        currentIndex++;
-    }
-    if (activeServicesMap.getSize() == 0)
-    {
-        std::cout << "No active services available." << std::endl;
-        return nullptr;
-    }
-    std::cout << "Enter service index: ";
-    util::read(userInputIndex);
-    if (activeServicesMap.find(userInputIndex) == -1)
-    {
-        std::cout << "Invalid service index." << std::endl;
-        return nullptr;
-    }
-    return activeServicesMap[userInputIndex];
-}
-
-/*
-Function: selectService
-Description: Allows the customer to select a service, provide vehicle details,
-             and book the service through the controller.
-Parameter: None
-Return type: void
-*/
 void CustomerMenu::selectService()
 {
-    std::string vehicleNumber, vehicleBrand, vehicleModel;
-	auto services = m_controller.getServices();
-    util::Vector<std::string> selectedServices;
-    util::clear();
-    const Service* selectedService = selectServiceFromServices(services);
-    if (selectedService == nullptr)
-    {
-        std::cout << "Failed to book service!";
-        util::pressEnter();
-        return;
-    }
-    selectedServices.push_back(selectedService->getId());
-    util::clear();
-    std::cout << "Enter vehicle number: ";
-    util::read(vehicleNumber);
-    std::cout << "Enter vehicle brand: ";
-    util::read(vehicleBrand);
-    std::cout << "Enter vehicle model: ";
-    util::read(vehicleModel);
-    m_controller.purchaseService(selectedServices, vehicleNumber, vehicleBrand, vehicleModel);
-    std::cout << "Service has been booked successfully";
-    util::pressEnter();
 }
 
-/*
-Function: selectComboPackageFromPackages
-Description: Displays active combo packages and allows the customer to select one by index.
-Parameter: const util::Map<std::string, const ComboPackage*>& comboPackages - list of combo packages
-Return type: const ComboPackage* - selected combo package
-*/
-static const ComboPackage* selectComboPackageFromPackages(const util::Map<std::string, const ComboPackage*>& comboPackages)
-{
-    util::Map<int, const ComboPackage*> activeComboPackages;
-    int currentIndex = 1;
-    int userInputIndex;
-    std::cout << std::left
-        << std::setw(10) << "Index"
-        << std::setw(15) << "Combo Package ID"
-        << std::setw(15) << "Combo Package Name"
-        << std::setw(15) << "Estimate Cost"
-        << std::endl;
-    for (int index = 0; index < comboPackages.getSize(); index++)
-    {
-        const ComboPackage* currentComboPackage = comboPackages.getValueAt(index);
-        if (currentComboPackage->getState() != util::State::ACTIVE)
-        {
-            continue;
-        }
-        activeComboPackages.insert(currentIndex, currentComboPackage);
-        std::cout << std::left
-            << std::setw(10) << currentIndex
-            << std::setw(15) << currentComboPackage->getId()
-            << std::setw(25) << currentComboPackage->getPackageName()
-            << std::setw(15) << calculateComboServiceEstimatedCost(currentComboPackage)
-            << std::endl;
-        currentIndex++;
-    }
-    if (activeComboPackages.getSize() == 0)
-    {
-        std::cout << "No active combo packages available." << std::endl;
-        return nullptr;
-    }
-    std::cout << "Enter combo package index: ";
-    util::read(userInputIndex);
-    if (activeComboPackages.find(userInputIndex) == -1)
-    {
-        std::cout << "Invalid combo package index." << std::endl;
-        return nullptr;
-    }
-    return activeComboPackages[userInputIndex];
-}
-
-/*
-Function: selectComboPackage
-Description: Allows the customer to select a combo package, provide vehicle details,
-             and book the package through the controller.
-Parameter: None
-Return type: void
-*/
 void CustomerMenu::selectComboPackage()
 {
-    std::string vehicleNumber, vehicleBrand, vehicleModel;
-    auto comboPackages = m_controller.getComboPackages();
-    util::clear();
-    const ComboPackage* selectedComboPackage = selectComboPackageFromPackages(comboPackages);
-    if (selectedComboPackage == nullptr)
-    {
-        std::cout << "Failed to book combo package!";
-        util::pressEnter();
-        return;
-    }
-    util::clear();
-    std::cout << "Enter vehicle number: ";
-    util::read(vehicleNumber);
-    std::cout << "Enter vehicle brand: ";
-    util::read(vehicleBrand);
-    std::cout << "Enter vehicle model: ";
-    util::read(vehicleModel);
-    m_controller.purchaseComboPackage(selectedComboPackage->getId(), vehicleNumber, vehicleBrand, vehicleModel);
-    std::cout << "Combo Package has been booked successfully";
-    util::pressEnter();
 }
 
 void CustomerMenu::viewServiceHistory()
 {
 }
 
-void CustomerMenu::completePayments()
+/*
+Function: selectInvoiceFromUserForPayment (static helper)
+Description: Lists all pending invoices for the customer and allows selection by index.
+Parameters:
+    - currentInvoices: util::Map<std::string, const Invoice*>&, map of customer invoices
+Returns:
+    - std::string: ID of the selected invoice, or empty string if none selected
+*/
+static std::string selectInvoiceFromUserForPayment(const util::Map<std::string, const Invoice*>& currentInvoices)
 {
+    int currentIndex = 1, choice;
+    util::Map<int, const Invoice*> pendingInvoicesForPayment;
+    std::cout << std::left
+        << std::setw(6) << "Index"
+        << std::setw(12) << "BookingID"
+        << std::setw(15) << "VehicleBrand"
+        << std::setw(15) << "VehicleNumber"
+        << std::setw(12) << "TechID"
+        << std::setw(20) << "TechnicianName"
+        << std::setw(10) << "Discount(%)"
+        << std::setw(12) << "TotalAmount"
+        << std::setw(20) << "InvoiceDate"
+        << std::endl;
+    for (int iterator = 0; iterator < currentInvoices.getSize(); iterator++)
+    {
+        const Invoice* currentInvoice = currentInvoices.getValueAt(iterator);
+        if (currentInvoice && currentInvoice->getStatus() == util::PaymentStatus::PENDING)
+        {
+            std::cout << std::left
+                << std::setw(6) << currentIndex
+                << std::setw(12) << currentInvoice->getBookingId()
+                << std::setw(15) << currentInvoice->getBooking()->getVehicleBrand()
+                << std::setw(15) << currentInvoice->getBooking()->getVehicleNumber()
+                << std::setw(12) << currentInvoice->getBooking()->getAssignedTechnician()->getId()
+                << std::setw(20) << currentInvoice->getBooking()->getAssignedTechnician()->getName()
+                << std::setw(10) << currentInvoice->getDiscountPercentage()
+                << std::setw(12) << currentInvoice->getTotalAmount()
+                << std::setw(20) << currentInvoice->getInvoiceDate().toString()
+                << std::endl;
+            pendingInvoicesForPayment.insert(currentIndex++, currentInvoice);
+        }
+    }
+    if (pendingInvoicesForPayment.getSize() == 0)
+    {
+        std::cout << "No pending invoices available for payment.\n";
+        return "";
+    }
+    std::cout << "Select the Invoice to pay (Index): ";
+    util::read(choice);
+    int selectedIndex = pendingInvoicesForPayment.find(choice);
+    if (selectedIndex != -1)
+    {
+        const Invoice* selectedInvoice = pendingInvoicesForPayment.getValueAt(selectedIndex);
+        return selectedInvoice->getId();
+    }
+    else
+    {
+        std::cout << "Invalid choice.\n";
+        return "";
+    }
 }
 
+/*
+Function: selectPaymentMode (static helper)
+Description: Allows the customer to select a payment mode (ONLINE or OFFLINE).
+Parameters:
+    - None
+Returns:
+    - util::PaymentMode: Selected payment mode
+*/
+static util::PaymentMode selectPaymentMode()
+{
+    int choice;
+    std::cout << "Enter the payment Mode\n1.OFFLINE\n2.ONLINE\nChoice: ";
+    util::read(choice);
+    if (choice == 1)
+    {
+        std::cout << "Offline mode selected.\n";
+        return util::PaymentMode::OFFLINE;
+    }
+    else if (choice == 2)
+    {
+        std::cout << "Online mode selected.\n";
+        return util::PaymentMode::ONLINE;
+    }
+    else
+    {
+        std::cout << "Invalid choice, Offline mode selected.\n";
+        return util::PaymentMode::OFFLINE;
+    }
+}
+
+/*
+Function: completePayments
+Description: Allows the customer to complete pending payments for invoices.
+             Validates invoice selection and payment mode before completing payment.
+Parameters:
+    - None
+Returns:
+    - void
+*/
+void CustomerMenu::completePayments()
+{
+	util::clear();
+	util::Map<std::string, const Invoice*> currentInvoices = m_controller.getInvoicesByUser();
+	std::string selectedID = selectInvoiceFromUserForPayment(currentInvoices);
+    if (selectedID == "")
+    {
+        std::cout << "Payment failed.\n";
+        return;
+    }
+    util::PaymentMode paymentMode = selectPaymentMode();
+    m_controller.completePayment(selectedID, paymentMode);
+    std::cout << "Payment completed successfully.\n";
+}
+
+/*
+Function: displayInvoices (static helper)
+Description: Displays detailed information for all invoices associated with the customer,
+             including booking details, technician, discount, total amount, payment status, and items used.
+Parameters:
+    - currentUserInvoices: util::Map<std::string, const Invoice*>, customer’s invoices
+Returns:
+    - void
+Throws:
+    - std::runtime_error if a null invoice is encountered
+*/
+static void displayInvoices(util::Map<std::string, const Invoice*> currentUserInvoices)
+{
+	if (currentUserInvoices.getSize() == 0)
+	{
+		std::cout << "No invoices found for this account." << std::endl;
+		util::pressEnter();
+		return;
+	}
+	else
+	{
+        for (int index = 0; index < currentUserInvoices.getSize(); index++)
+        {
+            const Invoice* currentInvoice = currentUserInvoices.getValueAt(index);
+            if (currentInvoice)
+            {
+                std::cout << "\nInvoice Details\n";
+                std::cout << "Booking ID: " << currentInvoice->getBookingId() << std::endl;
+                std::cout << "Vehicle Brand: " << currentInvoice->getBooking()->getVehicleBrand() << std::endl;
+                std::cout << "Vehicle Number: " << currentInvoice->getBooking()->getVehicleNumber() << std::endl;
+                std::cout << "Technician ID: " << currentInvoice->getBooking()->getAssignedTechnician()->getId() << std::endl;
+                std::cout << "Technician Name: " << currentInvoice->getBooking()->getAssignedTechnician()->getName() << std::endl;
+                std::cout << "Discount(%): " << currentInvoice->getDiscountPercentage() << std::endl;
+                std::cout << "Total Amount: " << currentInvoice->getTotalAmount() << std::endl;
+                std::cout << "Invoice Date: " << currentInvoice->getInvoiceDate().toString() << std::endl;
+                std::cout << "Payment Status: " << util::getPaymentStatusString(currentInvoice->getStatus()) << std::endl;
+                auto inventoryItemsInInvoice = currentInvoice->getParts();
+                std::cout << "\nItems Used:\n";
+                std::cout << std::left
+                    << std::setw(20) << "ItemName"
+                    << std::setw(10) << "Quantity"
+                    << std::setw(10) << "Price"
+                    << std::endl;
+                std::cout << std::string(40, '-') << std::endl;
+                for (int iterator = 0; iterator < inventoryItemsInInvoice.getSize(); iterator++)
+                {
+                    InventoryItem* currentItem = inventoryItemsInInvoice.getValueAt(iterator);
+                    std::cout << std::left
+                        << std::setw(20) << currentItem->getPartName()
+                        << std::setw(10) << currentItem->getQuantity()
+                        << std::setw(10) << currentItem->getPrice()
+                        << std::endl;
+                }
+            }
+            else
+            {
+                throw std::runtime_error("Null invoice encountered while displaying invoices.");
+            }
+        }
+	}
+}
+
+/*
+Function: viewInvoices
+Description: Displays invoices associated with the customer by calling displayInvoices.
+Parameters:
+    - None
+Returns:
+    - void
+*/
 void CustomerMenu::viewInvoices()
 {
+	util::clear();
+	util::Map<std::string, const Invoice*> currentUserInvoices = m_controller.getInvoicesByUser();
+	displayInvoices(currentUserInvoices);
 }
 
 void CustomerMenu::viewNotifications()
@@ -350,4 +263,4 @@ void CustomerMenu::viewNotifications()
 
 void CustomerMenu::configureNotifications()
 {
-}
+}

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

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

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

@@ -1,25 +1,7 @@
-/*
-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()
 {
 	bool isMenuActive = true;
@@ -44,12 +26,6 @@ void UserInterface::run()
 	}
 }
 
-/*
-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)
@@ -70,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"