Add standardized documentation headers

<UserStory> ADM005: Change Password </UserStory>

<Changes>
    1. Added AuthenticationManagementService::changePassword to update the authenticated user’s password with validation.
    2. Integrated Controller::changePassword to delegate password update requests to AuthenticationManagementService.
    3. Enhanced AdminMenu::changePassword to prompt for new password, validate strength using Validator, and confirm update.
    4. Added error handling to prevent password change when no user is logged in.
    5. Provided user feedback messages for invalid password attempts and successful updates.
</Changes>

<Test>

  Precondition:
  1. Admin is logged into the system.
  2. AuthenticationManagementService maintains active session.
  3. Validator is available for password strength checks.

  Steps:
  1. Navigate to Admin Menu and select "Change Password".
  2. Enter old password incorrectly.
    - Verify that system rejects the attempt and displays error.
  3. Enter new password that fails validation (length/complexity).
    - Verify that system rejects with "Error: Password is not strong enough!".
  4. Enter valid old password and strong new password.
    - Verify that system confirms "Password changed successfully" and updates the user’s password.
</Test>

<Review>
Sreeja Reghukumar
</Review>

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

@@ -176,6 +176,7 @@
     <ClInclude Include="utilities\Map.h" />
     <ClInclude Include="utilities\OutputHelper.h" />
     <ClInclude Include="utilities\Timestamp.h" />
+    <ClInclude Include="utilities\Utility.h" />
     <ClInclude Include="utilities\Validator.h" />
     <ClInclude Include="utilities\Vector.h" />
     <ClInclude Include="views\AdminMenu.h" />

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

@@ -233,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,20 +1,42 @@
+/*
+File: Controller.cpp
+Description: Implementation file containing the method definitions of the
+             Controller class, which manages authentication, users, services,
+             combo packages, and inventory operations.
+Author: Trenser
+Date:19-May-2026
+*/
 #include "Controller.h"
-#include "InventoryItem.h"
+#include "ComboPackage.h"
-#include "Service.h"
+#include "User.h"
-#include "ServiceBooking.h"
-#include "JobCard.h"
 
 bool Controller::login(const std::string& username, const std::string& password)
 {
     return false;
 }
 
+/*
+Function: logout
+Description: Logs out the currently authenticated user by delegating
+             to the authentication management service.
+Parameter: None
+Return type: void
+*/
 void Controller::logout()
 {
+    m_authenticationManagementService.logout();
 }
 
+/*
+Function: changePassword
+Description: Updates the password of the authenticated user by delegating
+             to the authentication management service.
+Parameter: const std::string& newPassword - the 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)
@@ -26,36 +48,50 @@ const User* Controller::getAuthenticatedUser()
     return nullptr;
 }
 
-void Controller::createTechnician(const std::string& username, const std::string& password, const std::string& email, const std::string& phone)
+/*
+Function: createTechnician
+Description: Creates a new technician account with provided details by
+             delegating to the user management service.
+Parameter: const std::string& username - technician's username
+           const std::string& password - technician's password
+           const std::string& email - technician's email address
+           const std::string& phoneNumber - technician's phone number
+Return type: void
+*/
+void Controller::createTechnician(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phoneNumber)
 {
+    m_userManagementService.createUser(username, name, password, email, phoneNumber, util::UserType::TECHNICIAN);
 }
 
 void Controller::updateUserDetails(const std::string& email, const std::string& phone)
 {
 }
 
-/*
-Function: getServices
-Description: Retrieves all available services in read-only form.
-Parameters:
-    - None
-Returns:
-    - util::Map<std::string, const Service*> containing all services
-*/
 util::Map<std::string, const Service*> Controller::getServices()
 {
-    util::Map<std::string, Service*> currentServices = m_serviceManagementService.getServices();
+    return util::Map<std::string, const Service*>();
-    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;
 }
 
+/*
+Function: getComboPackages
+Description: Retrieves all available combo packages from the service
+             management service and constructs a read-only map.
+Parameter: None
+Return type: util::Map<std::string, const ComboPackage*>
+*/
 util::Map<std::string, const ComboPackage*> Controller::getComboPackages()
 {
-    return util::Map<std::string, const ComboPackage*>();
+    util::Map<std::string, ComboPackage*> currentAvailableComboPackages = m_serviceManagementService.getComboPackages();
+    util::Map<std::string, const ComboPackage*> readOnlyComboPackages;
+    for (int iterator = 0; iterator < currentAvailableComboPackages.getSize(); iterator++)
+    {
+        ComboPackage* currentComboPackage = currentAvailableComboPackages.getValueAt(iterator);
+        if (currentComboPackage)
+        {
+            readOnlyComboPackages.insert(currentComboPackage->getId(), currentComboPackage);
+        }
+    }
+    return readOnlyComboPackages;
 }
 
 void Controller::purchaseService(const util::Vector<std::string>& serviceIDs, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
@@ -68,8 +104,7 @@ void Controller::purchaseComboPackage(const std::string& comboPackageID, const s
 
 util::Map<std::string, const InventoryItem*> Controller::getInventoryItems()
 {
-    util::Map<std::string, const InventoryItem*> dummyMap;
+    return util::Map<std::string, const InventoryItem*>();
-    return dummyMap;
 }
 
 const InventoryItem* Controller::getInventoryItem(const std::string& inventoryItemID)
@@ -85,155 +120,103 @@ 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()
 {
-    auto serviceBookings = m_serviceManagementService.getServiceBookings();
+    return util::Map<std::string, const ServiceBooking*>();
-    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)
 {
-    util::Map<std::string, const ServiceBooking*> readOnlyServiceBookingsByUserMap;
+    return util::Map<std::string, const ServiceBooking*>();
-    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()
-{
-    return util::Map<std::string, const User*>();
 }
 
 /*
 Function: getUsers
-Description: Retrieves users filtered by user type.
+Description: Retrieves all users from the user management service and
-Parameters:
+             constructs a read-only map.
-    - userType: util::UserType, type of user (CUSTOMER, TECHNICIAN, ADMIN)
+Parameter: None
-Returns:
+Return type: util::Map<std::string, const User*>
-    - util::Map<std::string, const User*> containing users of the specified type
 */
+util::Map<std::string, const User*> Controller::getUsers()
+{
+    auto listOfUsers = m_userManagementService.getUsers();
+    util::Map<std::string, const User*> readOnlyUserList;
+    for (int iterator = 0; iterator < listOfUsers.getSize(); iterator++)
+    {
+        readOnlyUserList.insert(listOfUsers.getKeyAt(iterator), listOfUsers.getValueAt(iterator));
+    }
+    return readOnlyUserList;
+}
+
 util::Map<std::string, const User*> Controller::getUsers(util::UserType userType)
 {
-    auto userMap = m_userManagementService.getUsers(userType);
+    return util::Map<std::string, const User*>();
-    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()
 {
-    const User* currentUser = getAuthenticatedUser();
+    return util::Map<std::string, const JobCard*>();
-    auto jobCardsAssignedToTechnician = m_serviceManagementService.getJobCards(currentUser->getId());
+}
-    util::Map<std::string, const JobCard*> readOnlyJobCardMap;
+
-    for (int iterator = 0; iterator < jobCardsAssignedToTechnician.getSize(); iterator++)
+void Controller::completeJob(const std::string& jobID)
-    {
+{
-        JobCard* currentJobCard = jobCardsAssignedToTechnician.getValueAt(iterator);
-        readOnlyJobCardMap.insert(currentJobCard->getId(), currentJobCard);
-    }
-    return readOnlyJobCardMap;
 }
 
 /*
-Function: completeJob
+Function: removeUser
-Description: Marks a job card as completed.
+Description: Removes a user by ID. Cancels associated service bookings
-Parameters:
+             and technician jobs before removing the user from the system.
-    - jobID: std::string, ID of the job card
+Parameter: const std::string& userID - ID of the user to remove
-Returns:
+Return type: void
-    - void
 */
-void Controller::completeJob(const std::string& jobID)
-{
-    m_serviceManagementService.completeJob(jobID);
-}
-
 void Controller::removeUser(const std::string& userID)
 {
+    User* user = m_userManagementService.getUser(userID);
+    if (!user)
+    {
+        throw std::runtime_error("Error User not Found.\n");
+    }
+    m_serviceManagementService.cancelCustomerServiceBookings(userID);
+    m_serviceManagementService.cancelTechnicianJobs(userID);
+    m_userManagementService.removeUser(userID);
 }
 
+/*
+Function: createComboPackage
+Description: Creates a new combo package with specified services and discount
+             percentage by delegating to the service management service.
+Parameter: const std::string& name - name of the combo package
+           const util::Vector<std::string>& serviceIDs - list of service IDs
+           double discountPercentage - discount percentage for the package
+Return type: void
+*/
 void Controller::createComboPackage(const std::string& name, const util::Vector<std::string>& serviceIDs, double discountPercentage)
 {
+    m_serviceManagementService.createComboPackage(name, serviceIDs, discountPercentage);
 }
 
+/*
+Function: removeComboPackage
+Description: Removes a combo package by ID by delegating to the service
+             management service.
+Parameter: const std::string& comboPackageID - ID of the combo package
+Return type: void
+*/
 void Controller::removeComboPackage(const std::string& comboPackageID)
 {
+    m_serviceManagementService.removeComboPackage(comboPackageID);
 }
 
 util::Map<std::string, const Invoice*> Controller::getInvoicesByUser()

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

@@ -1,10 +1,18 @@
+/*
+File: Controller.h
+Description: Header file declaring the Controller class, which manages
+             user authentication, inventory, services, bookings, job cards,
+             invoices, and notifications in the system.
+Author: Trenser
+Date:19-May-2026
+*/
 #pragma once
-#include "Map.h"
 #include <string>
+#include "Map.h"
 #include "Enums.h"
-#include "ServiceManagementService.h"
 #include "UserManagementService.h"
-#include "InventoryManagementService.h"
+#include "ServiceManagementService.h"
+#include "AuthenticationManagementService.h"
 
 class Service;
 class ComboPackage;
@@ -18,15 +26,16 @@ class Notification;
 class Controller
 {
 private:
-    ServiceManagementService m_serviceManagementService;
+    AuthenticationManagementService  m_authenticationManagementService;
     UserManagementService m_userManagementService;
+    ServiceManagementService m_serviceManagementService;    
 public:
     bool login(const std::string& username, const std::string& password);
     void logout();
     void changePassword(const std::string& newPassword);
     void createCustomer(const std::string& username, const std::string& password, const std::string& email, const std::string& phone);
     const User* getAuthenticatedUser();
-    void createTechnician(const std::string& username, const std::string& password, const std::string& email, const std::string& phone);
+    void createTechnician(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phoneNumber);
     void updateUserDetails(const std::string& email, const std::string& phone);
     util::Map<std::string, const Service*> getServices();
     util::Map<std::string, const ComboPackage*> getComboPackages();

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

@@ -1,7 +1,22 @@
+/*
+File: JobCard.cpp
+Description: Implementation file containing the method definitions of the
+             JobCard class, including constructors, getters, and setters
+             for job card attributes.
+Author: Trenser
+Date:19-May-2026
+*/
 #include "JobCard.h"
 
 int JobCard::m_uid = 0;
 
+/*
+Function: JobCard
+Description: Default constructor that initializes a new job card with
+             a unique ID and default values.
+Parameter: None
+Return type: Constructor
+*/
 JobCard::JobCard()
     : m_id("JC" + std::to_string(++m_uid)),
     m_booking(nullptr),
@@ -9,6 +24,21 @@ JobCard::JobCard()
     m_technician(nullptr),
     m_status(util::ServiceJobStatus()) {}
 
+/*
+Function: JobCard
+Description: Parameterized constructor that initializes a job card with
+             booking, service, technician, and status details.
+Parameter: const std::string& bookingId - ID of the booking
+           ServiceBooking* booking - pointer to the booking object
+           Service* service - pointer to the service object
+           const std::string& serviceId - ID of the service
+           const std::string& technicianId - ID of the technician
+           User* technician - pointer to the technician object
+           const util::Timestamp& assignedDate - date when job was assigned
+           util::ServiceJobStatus status - current status of the job
+           const util::Timestamp& completionDate - date when job was completed
+Return type: Constructor
+*/
 JobCard::JobCard(const std::string& bookingId,
     ServiceBooking* booking,
     Service* service,
@@ -30,101 +60,221 @@ JobCard::JobCard(const std::string& bookingId,
     m_status(status),
     m_completionDate(completionDate) {}
 
+/*
+Function: getId
+Description: Retrieves the unique identifier of the job card.
+Parameter: None
+Return type: const std::string&
+*/
 const std::string& JobCard::getId() const
 {
     return m_id;
 }
 
+/*
+Function: getBookingId
+Description: Retrieves the booking ID associated with the job card.
+Parameter: None
+Return type: const std::string&
+*/
 const std::string& JobCard::getBookingId() const
 {
     return m_bookingId;
 }
 
+/*
+Function: getBooking
+Description: Retrieves the booking object associated with the job card.
+Parameter: None
+Return type: ServiceBooking*
+*/
 ServiceBooking* JobCard::getBooking() const
 {
     return m_booking;
 }
 
+/*
+Function: getService
+Description: Retrieves the service object associated with the job card.
+Parameter: None
+Return type: Service*
+*/
 Service* JobCard::getService() const
 {
     return m_service;
 }
 
+/*
+Function: getServiceId
+Description: Retrieves the service ID associated with the job card.
+Parameter: None
+Return type: const std::string&
+*/
 const std::string& JobCard::getServiceId() const
 {
     return m_serviceId;
 }
 
+/*
+Function: getTechnicianId
+Description: Retrieves the technician ID assigned to the job card.
+Parameter: None
+Return type: const std::string&
+*/
 const std::string& JobCard::getTechnicianId() const
 {
     return m_technicianId;
 }
 
+/*
+Function: getTechnician
+Description: Retrieves the technician object assigned to the job card.
+Parameter: None
+Return type: User*
+*/
 User* JobCard::getTechnician() const
 {
     return m_technician;
 }
 
+/*
+Function: getAssignedDate
+Description: Retrieves the date when the job was assigned.
+Parameter: None
+Return type: const util::Timestamp&
+*/
 const util::Timestamp& JobCard::getAssignedDate() const
 {
     return m_assignedDate;
 }
 
+/*
+Function: getStatus
+Description: Retrieves the current status of the job card.
+Parameter: None
+Return type: util::ServiceJobStatus
+*/
 util::ServiceJobStatus JobCard::getStatus() const
 {
     return m_status;
 }
 
+/*
+Function: getCompletionDate
+Description: Retrieves the completion date of the job card.
+Parameter: None
+Return type: const util::Timestamp&
+*/
 const util::Timestamp& JobCard::getCompletionDate() const
 {
     return m_completionDate;
 }
 
+/*
+Function: setId
+Description: Sets the unique identifier of the job card.
+Parameter: const std::string& id - new job card ID
+Return type: void
+*/
 void JobCard::setId(const std::string& id)
 {
     m_id = id;
 }
 
+/*
+Function: setBookingId
+Description: Sets the booking ID for the job card.
+Parameter: const std::string& bookingId - new booking ID
+Return type: void
+*/
 void JobCard::setBookingId(const std::string& bookingId)
 {
     m_bookingId = bookingId;
 }
 
+/*
+Function: setBooking
+Description: Sets the booking object for the job card.
+Parameter: ServiceBooking* booking - pointer to the booking object
+Return type: void
+*/
 void JobCard::setBooking(ServiceBooking* booking)
 {
     m_booking = booking;
 }
 
+/*
+Function: setService
+Description: Sets the service object for the job card.
+Parameter: Service* service - pointer to the service object
+Return type: void
+*/
 void JobCard::setService(Service* service)
 {
     m_service = service;
 }
 
+/*
+Function: setServiceId
+Description: Sets the service ID for the job card.
+Parameter: const std::string& serviceId - new service ID
+Return type: void
+*/
 void JobCard::setServiceId(const std::string& serviceId)
 {
     m_serviceId = serviceId;
 }
 
+/*
+Function: setTechnicianId
+Description: Sets the technician ID for the job card.
+Parameter: const std::string& technicianId - new technician ID
+Return type: void
+*/
 void JobCard::setTechnicianId(const std::string& technicianId)
 {
     m_technicianId = technicianId;
 }
 
+/*
+Function: setTechnician
+Description: Sets the technician object for the job card.
+Parameter: User* technician - pointer to the technician object
+Return type: void
+*/
 void JobCard::setTechnician(User* technician)
 {
     m_technician = technician;
 }
 
+/*
+Function: setAssignedDate
+Description: Sets the assigned date for the job card.
+Parameter: const util::Timestamp& assignedDate - new assigned date
+Return type: void
+*/
 void JobCard::setAssignedDate(const util::Timestamp& assignedDate)
 {
     m_assignedDate = assignedDate;
 }
 
+/*
+Function: setStatus
+Description: Sets the status of the job card.
+Parameter: util::ServiceJobStatus status - new job status
+Return type: void
+*/
 void JobCard::setStatus(util::ServiceJobStatus status)
 {
     m_status = status;
 }
 
+/*
+Function: setCompletionDate
+Description: Sets the completion date for the job card.
+Parameter: const util::Timestamp& completionDate - new completion date
+Return type: void
+*/
 void JobCard::setCompletionDate(const util::Timestamp& completionDate)
 {
     m_completionDate = completionDate;

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

@@ -1,3 +1,11 @@
+/*
+File: JobCard.h
+Description: Header file declaring the JobCard class, which represents
+             a service job card containing booking, service, technician,
+             and status details.
+Author: Trenser
+Date:19-May-2026
+*/
 #pragma once
 #include <string>
 #include "Timestamp.h"
@@ -21,7 +29,6 @@ private:
     util::Timestamp m_assignedDate;
     util::ServiceJobStatus m_status;
     util::Timestamp m_completionDate;
-
 public:
     JobCard();
     JobCard(const std::string& bookingId,

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

@@ -1,12 +1,44 @@
+/*
+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, and zero discount.
+Parameter: None
+Return type: Constructor
+*/
 ServiceBooking::ServiceBooking()
     : m_id("SRV" + std::to_string(++m_uid)),
     m_customer(nullptr),
     m_discountPercentage(0.0) {}
 
+/*
+Function: ServiceBooking
+Description: Parameterized constructor that initializes a service booking
+             with customer, vehicle, technician, and discount details.
+Parameter: const std::string& id - booking ID
+           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
+           const std::string& assignedTechnicianId - ID of the assigned technician
+           User* assignedTechnician - pointer to the technician object
+           double discountPercentage - discount applied to the booking
+Return type: Constructor
+*/
 ServiceBooking::ServiceBooking(
     const std::string& id,
     util::ServiceJobStatus status,
@@ -18,7 +50,7 @@ ServiceBooking::ServiceBooking(
     const std::string& vehicleBrand,
     const std::string& vehicleModel,
     const std::string& assignedTechnicianId,
-    const User* assignedTechnician,
+    User* assignedTechnician,
     double discountPercentage
 )
     : m_id("SRV" + std::to_string(++m_uid)),
@@ -35,111 +67,243 @@ ServiceBooking::ServiceBooking(
 {
 }
 
+/*
+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;
 }
 
-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;
 }
 
+/*
+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;

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

@@ -1,3 +1,11 @@
+/*
+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"
@@ -19,7 +27,7 @@ private:
     std::string m_vehicleBrand;
     std::string m_vehicleModel;
     std::string m_assignedTechnicianId;
-    const User* m_assignedTechnician;
+    User* m_assignedTechnician;
     double m_discountPercentage;
 public:
     ServiceBooking();
@@ -34,7 +42,7 @@ public:
         const std::string& vehicleBrand,
         const std::string& vehicleModel,
         const std::string& assignedTechnicianId,
-        const User* assignedTechnician,
+        User* assignedTechnician,
         double discountPercentage
     );
     const std::string& getId() const;
@@ -46,7 +54,7 @@ public:
     const std::string& getVehicleBrand() const;
     const std::string& getVehicleModel() const;
     const std::string& getAssignedTechnicianId() const;
-    const User* getAssignedTechnician() const;
+    User* getAssignedTechnician() const;
     double getDiscountPercentage() const;
     void setId(const std::string& id);
     void setStatus(const util::ServiceJobStatus& status);
@@ -57,6 +65,6 @@ public:
     void setVehicleBrand(const std::string& vehicleBrand);
     void setVehicleModel(const std::string& vehicleModel);
     void setAssignedTechnicianId(const std::string& assignedTechnicianId);
-    void setAssignedTechnician(const User* assignedTechnician);
+    void setAssignedTechnician(User* assignedTechnician);
     void setDiscountPercentage(double discountPercentage);
 };

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

@@ -1,3 +1,40 @@
+/*
+File: AuthenticationManagementService.cpp
+Description: Implementation file containing the method definitions of the
+			 AuthenticationManagementService class, including logout and
+			 password change logic.
+Author: Trenser
+Date:19-May-2026
+*/
 #include "AuthenticationManagementService.h"
+#include "User.h"
 
 User* AuthenticationManagementService::m_authenticatedUser = nullptr;
+
+/*
+Function: logout
+Description: Logs out the currently authenticated user by clearing the
+			 static authenticated user pointer.
+Parameter: None
+Return type: void
+*/
+void AuthenticationManagementService::logout()
+{
+	m_authenticatedUser = nullptr;
+}
+
+/*
+Function: changePassword
+Description: Changes the password of the currently authenticated user.
+			 Throws an exception if no user is logged in.
+Parameter: const std::string& newPassword - new password to set
+Return type: void
+*/
+void AuthenticationManagementService::changePassword(const std::string& newPassword)
+{
+	if (m_authenticatedUser == nullptr)
+	{
+		throw std::runtime_error("There is no user currently logged in!");
+	}
+	m_authenticatedUser->setPassword(newPassword);
+}

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

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

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

@@ -1,324 +1,231 @@
+/*
+File: ServiceManagementService.cpp
+Description: Implementation file containing the method definitions of the
+             ServiceManagementService class, including service booking cancellation,
+             job card management, combo package creation, and removal logic.
+Author: Trenser
+Date:19-May-2026
+*/
 #include "ServiceManagementService.h"
-#include "UserManagementService.h"
+#include "DataStore.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 "Factory.h"
-#include "PaymentManagementService.h"
+#include "ComboPackage.h"
-#include "NotificationManagementService.h"
-#include "User.h"
 
 /*
-Function: getServiceBookings
+Function: cancelCustomerServiceBookings
-Description: Retrieves all service bookings from the datastore.
+Description: Cancels all service bookings associated with a given customer or technician.
-Parameters:
+             Updates booking status, resets customer/technician assignments, sends notifications,
-	- None
+             and restocks inventory items.
-Returns:
+Parameter: const std::string& userID - ID of the customer or technician
-	- util::Map<std::string, ServiceBooking*> containing all service bookings
+Return type: void
 */
-util::Map<std::string, ServiceBooking*> ServiceManagementService::getServiceBookings()
+void ServiceManagementService::cancelCustomerServiceBookings(const std::string& userID)
 {
-	return m_dataStore.getServiceBookings();
+    const int INCREMENT_VALUE = 1;
+    auto& users = m_dataStore.getUsers();
+    int userIndex = users.find(userID);
+    if (userIndex == -1)
+    {
+        throw std::runtime_error("User not found: " + userID);
+    }
+    User* user = users.getValueAt(userIndex);
+    if (user == nullptr)
+    {
+        throw std::runtime_error("User not found: " + userID);
+    }
+    util::UserType type = user->getUserType();
+    auto& bookings = DataStore::getInstance().getServiceBookings();
+    for (int bookingIterator = 0; bookingIterator < bookings.getSize(); bookingIterator++)
+    {
+        ServiceBooking* booking = bookings.getValueAt(bookingIterator);
+        if (booking != nullptr &&
+            (booking->getCustomerId() == userID || booking->getAssignedTechnicianId() == userID))
+        {
+            if (booking->getStatus() == util::ServiceJobStatus::PENDING ||
+                booking->getStatus() == util::ServiceJobStatus::STARTED)
+            {
+                if (type == util::UserType::CUSTOMER)
+                {
+                    booking->setStatus(util::ServiceJobStatus::CANCELLED);
+                    booking->setCustomer(nullptr);
+                    booking->setCustomerId("");
+                    User* assignedTechnician = booking->getAssignedTechnician();
+                    sendNotification(assignedTechnician, "Customer Service Cancelled", "Uh?Oh. The customer has cancelled their service booking. Your assigned job card has been cancelled and the inventory has been restocked.");
+                }
+                else if (type == util::UserType::TECHNICIAN)
+                {
+                    booking->setStatus(util::ServiceJobStatus::PENDING);
+                    sendNotification(booking->getCustomer(), "Technician Unavailable", "Your assigned technician is no longer available. Your booking has been reset to pending, and we will reassign a new technician shortly.");
+                }
+                booking->setAssignedTechnician(nullptr);
+                booking->setAssignedTechnicianId("");
+                const auto& ListOfServices = booking->getServices();
+                for (int serviceIterator = 0; serviceIterator < ListOfServices.getSize(); serviceIterator++)
+                {
+                    Service* service = ListOfServices.getValueAt(serviceIterator);
+                    if (service != nullptr)
+                    {
+                        const auto& items = service->getRequiredInventoryItems();
+                        for (int itemIterator = 0; itemIterator < items.getSize(); itemIterator++)
+                        {
+                            InventoryItem* item = items.getValueAt(itemIterator);
+                            if (item != nullptr)
+                            {
+                                item->setQuantity(item->getQuantity() + INCREMENT_VALUE);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
 }
 
 /*
-Function: getServiceBooking
+Function: cancelTechnicianJobs
-Description: Retrieves a specific service booking by its ID.
+Description: Cancels all jobs assigned to a technician. Updates job status, sends notifications,
-Parameters:
+             and restocks inventory items used in the service.
-	- serviceID: std::string, ID of the service booking
+Parameter: const std::string& technicianID - ID of the technician
-Returns:
+Return type: void
-	- ServiceBooking*: Pointer to the service booking, or nullptr if not found
 */
-ServiceBooking* ServiceManagementService::getServiceBooking(const std::string& serviceID)
+void ServiceManagementService::cancelTechnicianJobs(const std::string& technicianID)
 {
-	auto currentServiceBookings = getServiceBookings();
+    const int INCREMENT_VALUE = 1;
-	for (int iterator = 0; iterator < currentServiceBookings.getSize(); iterator++)
+    auto& jobs = m_dataStore.getJobCards();
+    for (int jobIterator = 0; jobIterator < jobs.getSize(); jobIterator++)
     {
-		if (currentServiceBookings.getValueAt(iterator)->getId() == serviceID)
+        JobCard* job = jobs.getValueAt(jobIterator);
+        if (job != nullptr && job->getTechnicianId() == technicianID)
         {
-			return currentServiceBookings.getValueAt(iterator);
+            if (job->getStatus() == util::ServiceJobStatus::PENDING || job->getStatus() == util::ServiceJobStatus::STARTED)
+            {
+                job->setStatus(util::ServiceJobStatus::CANCELLED);
+                sendNotification(job->getTechnician(), "Job Cancelled", "The Job has cancelled. Your job card has been cancelled and the inventory has been restocked.");
+                Service* service = job->getService();
+                if (service != nullptr)
+                {
+                    const auto& items = service->getRequiredInventoryItems();
+                    for (int itemIterator = 0; itemIterator < items.getSize(); itemIterator++)
+                    {
+                        InventoryItem* item = items.getValueAt(itemIterator);
+                        if (item != nullptr)
+                        {
+                            item->setQuantity(item->getQuantity() + INCREMENT_VALUE);
+                        }
+                    }
+                }
+            }
         }
     }
-	return nullptr;
 }
 
 /*
-Function: createJobCard
+Function: createComboPackage
-Description: Creates a job card for a given service booking, service, and technician.
+Description: Creates a new combo package with two services and a discount percentage.
-			 Validates booking, service, technician, and inventory availability before creation.
+             Validates service IDs, ensures uniqueness, and inserts the new package into the DataStore.
-Parameters:
+Parameter: const std::string& packageName - name of the combo package
-	- bookingID: std::string, ID of the service booking
+           const util::Vector<std::string>& serviceIDsInNewCombo - list of service IDs
-	- technicianID: std::string, ID of the technician
+           double discountPercentage - discount percentage for the package
-	- serviceID: std::string, ID of the service
+Return type: void
-Returns:
-	- void
-Throws:
-	- std::runtime_error if booking, service, technician, or inventory validation fails
 */
-void ServiceManagementService::createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID)
+void ServiceManagementService::createComboPackage(const std::string& packageName, const util::Vector<std::string>& serviceIDsInNewCombo, double discountPercentage)
 {
-	UserManagementService m_userManagementService;
+    if (packageName.empty())
-	ServiceBooking* currentBooking = getServiceBooking(bookingID);
-	auto& currentJobCards = m_dataStore.getJobCards();
-	if (currentBooking == nullptr)
     {
-		throw std::runtime_error("Service Booking not available");
+        throw std::invalid_argument("The Combo Package Name cannot be empty.\n");
     }
-	auto& currentServices = currentBooking->getServices();
+    if (serviceIDsInNewCombo.getSize() < 2 || serviceIDsInNewCombo.getSize() > 2)
-	if (currentServices.find(serviceID) == -1)
     {
-		throw std::runtime_error("Invalid service Id");
+        throw std::invalid_argument("Combo package must contain only two services.");
     }
-	Service* currentService = currentServices.getValueAt(currentServices.find(serviceID));
+    if (discountPercentage < 0.0 || discountPercentage > 100.0)
-	User* selectedTechnician = m_userManagementService.getUser(technicianID);
-	if (selectedTechnician == nullptr)
     {
-		throw std::runtime_error("Technician not available");
+        throw std::invalid_argument("Discount percentage must be between 0 and 100.");
     }
-	auto& inventoryItems = currentService->getRequiredInventoryItems();
+    auto& servicesMap = m_dataStore.getServices();
-	for (int iterator = 0; iterator < inventoryItems.getSize(); iterator++)
+    for (int index = 0; index < serviceIDsInNewCombo.getSize(); index++)
     {
-		InventoryItem* currentInventoryItem = inventoryItems.getValueAt(iterator);
+        const std::string serviceid = serviceIDsInNewCombo[index];
-		if (currentInventoryItem->getQuantity() == 0)
+        if (servicesMap.find(serviceid) == -1)
         {
-			std::string errorMessage = "Failed to create job card, " + currentInventoryItem->getPartName() + " is out of stock.";
+            throw std::runtime_error("Service ID not found: " + serviceid);
-			throw std::runtime_error(errorMessage);
-		}
-		else
-		{
-			int currentStockQuantity = currentInventoryItem->getQuantity();
-			currentInventoryItem->setQuantity(currentStockQuantity - 1);
         }
     }
-	currentBooking->setAssignedTechnician(selectedTechnician);
+    auto& comboPackageMap = m_dataStore.getComboPackages();
-	currentBooking->setAssignedTechnicianId(selectedTechnician->getId());
+    for (int iterator = 0; iterator < comboPackageMap.getSize(); iterator++)
-	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: createService
-Description: Creates a new service with associated inventory items and labor cost.
-			 Validates inventory items before creation.
-Parameters:
-	- name: std::string, name of the service
-	- inventoryItemIDs: util::Vector<std::string>, IDs of required inventory items
-	- laborCost: double, labor cost for the service
-Returns:
-	- void
-Throws:
-	- std::runtime_error if inventory items are not found or service creation fails
-*/
-void ServiceManagementService::createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost)
-{
-	util::Map<std::string, InventoryItem*> currentServiceInventoryItems;
-	auto inventoryItems = m_dataStore.getInventoryItems();
-	for (int iteratorOne =0; iteratorOne < inventoryItemIDs.getSize(); iteratorOne++)
     {
-		std::string currentItemID = inventoryItemIDs[iteratorOne];
+        ComboPackage* existingCombos = comboPackageMap.getValueAt(iterator);
-		bool itemFound = false;
+        const util::Map<std::string, Service*>& servicesInsideExistingCombos = existingCombos->getServices();
-		for (int iteratorTwo = 0; iteratorTwo < inventoryItems.getSize(); iteratorTwo++)
+        if (servicesInsideExistingCombos.getSize() == serviceIDsInNewCombo.getSize())
         {
-			InventoryItem* currentInventoryItem = inventoryItems.getValueAt(iteratorTwo);
+            bool isIdentical = true;
-			if (currentInventoryItem && currentInventoryItem->getId() == currentItemID)
+            for (int serviceIterator = 0; serviceIterator < serviceIDsInNewCombo.getSize(); serviceIterator++)
             {
-				itemFound = true;
+                const std::string& id = serviceIDsInNewCombo[serviceIterator];
-				currentServiceInventoryItems.insert(currentInventoryItem->getId(), currentInventoryItem);
+                if (servicesInsideExistingCombos.find(id) == -1)
+                {
+                    isIdentical = false;
                     break;
                 }
             }
-		if (!itemFound)
+            if (isIdentical)
             {
-			throw std::runtime_error("Inventory item with ID '" + currentItemID + "' not found.");
+                throw std::runtime_error("A combo package with the same services already exists.");
             }
         }
-	Service* newService = Factory::getObject<Service>(name, currentServiceInventoryItems, laborCost);
+    }
-	if (newService == nullptr)
+    util::Map<std::string, Service*> selectedServices;
+    for (int iteratorOne = 0; iteratorOne < serviceIDsInNewCombo.getSize(); iteratorOne++)
     {
-		throw std::runtime_error("Unable to create new service.");
+        const std::string& serviceId = serviceIDsInNewCombo[iteratorOne];
-	}
+        int serviceIndex = servicesMap.find(serviceId);
-	util::Map<std::string, Service*>& currentServices = m_dataStore.getServices();
+        if (serviceIndex == -1)
-	if (currentServices.find(newService->getId()) != -1)
         {
-		throw std::runtime_error("Service with this ID Already exists.");
+            throw std::runtime_error("Service ID not found: " + serviceId);
         }
-	currentServices.insert(newService->getId(), newService);
+        selectedServices.insert(serviceId, servicesMap.getValueAt(serviceIndex));
+    }
+    ComboPackage* newComboPackage = Factory::getObject<ComboPackage>(packageName, discountPercentage, selectedServices);
+    comboPackageMap.insert(newComboPackage->getId(), newComboPackage);
 }
 
 /*
-Function: getServices
+Function: getComboPackages
-Description: Retrieves all services from the datastore.
+Description: Retrieves all combo packages stored in the DataStore.
-Parameters:
+Parameter: None
-	- None
+Return type: util::Map<std::string, ComboPackage*>
-Returns:
-	- util::Map<std::string, Service*> containing all services
 */
-util::Map<std::string, Service*> ServiceManagementService::getServices()
+util::Map<std::string, ComboPackage*> ServiceManagementService::getComboPackages()
 {
-	return m_dataStore.getServices();
+    return m_dataStore.getComboPackages();
 }
 
 /*
-Function: removeService
+Function: removeComboPackage
-Description: Marks a service as inactive by its ID.
+Description: Removes a combo package by marking it inactive. Throws an exception if the package ID is not found.
-Parameters:
+Parameter: const std::string& comboPackageID - ID of the combo package
-	- serviceID: std::string, ID of the service
+Return type: void
-Returns:
-	- void
-Throws:
-	- std::runtime_error if the service is not found
 */
-void ServiceManagementService::removeService(const std::string& serviceID)
+void ServiceManagementService::removeComboPackage(const std::string& comboPackageID)
 {
-	util::Map<std::string, Service*> currentServices = getServices();
+    bool removed = false;
-	if (currentServices.find(serviceID) != -1)
+    util::Map<std::string, ComboPackage*>& currentComboPackages = m_dataStore.getComboPackages();
+    for (int iterator = 0; iterator < currentComboPackages.getSize(); iterator++)
     {
-		currentServices.getValueAt(currentServices.find(serviceID))->setState(util::State::INACTIVE);
+        ComboPackage* currentComboPackage = currentComboPackages.getValueAt(iterator);
+        if (currentComboPackage && currentComboPackage->getId() == comboPackageID)
+        {
+            currentComboPackage->setState(util::State::INACTIVE);
+            removed = true;
+            break;
         }
-	else
+    }
+    if (!removed)
     {
-		throw std::runtime_error("Service not found.");
+        throw std::runtime_error("Combo package with ID '" + comboPackageID + "' not found.");
-	}
-}
-
-/*
-Function: getServiceBookings (overloaded)
-Description: Retrieves all service bookings for a specific customer.
-Parameters:
-	- customerID: std::string, ID of the customer
-Returns:
-	- util::Map<std::string, ServiceBooking*> containing bookings for the customer
-*/
-util::Map<std::string, ServiceBooking*> ServiceManagementService::getServiceBookings(const std::string& customerID)
-{
-	util::Map<std::string, ServiceBooking*> currentServiceBookings = getServiceBookings();
-	util::Map<std::string, ServiceBooking*> currentUserServiceBookings;
-	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: getJobCards
-Description: Retrieves all job cards assigned to a specific technician.
-Parameters:
-	- 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 technician is not authenticated, job card not found, or job already completed
-*/
-void ServiceManagementService::completeJob(const std::string& jobID)
-{
-	AuthenticationManagementService authenticationManagementService;
-	PaymentManagementService paymentManagementService;
-	bool jobStatusUpdated = false, serviceBookingCompleted;
-	JobCard* currentJob;
-	User* currentTechnician = authenticationManagementService.getAuthenticatedUser();
-	if (currentTechnician == nullptr)
-	{
-		throw std::runtime_error("Unable to fetch current technician.");
-	}
-	util::Map<std::string, JobCard*> currentAssignedJobs = getJobCards(currentTechnician->getId());
-	if (currentAssignedJobs.getSize() == 0)
-	{
-		throw std::runtime_error("No job cards assigned to the technician.");
-	}
-	if (currentAssignedJobs.find(jobID) != -1)
-	{
-		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.");
-	}
-
-	serviceBookingCompleted = hasAllJobCardsinServiceBookingCompleted(currentJob->getBookingId(), currentAssignedJobs);
-	if (serviceBookingCompleted)
-	{
-		currentJob->getBooking()->setStatus(util::ServiceJobStatus::COMPLETED);
-		paymentManagementService.generateInvoice(currentJob->getBooking());
-		std::string title = "Service Booking completed,Invoice Generated.\n";
-		std::string message = "Services completed for the booking and invoice generated.\n";
-		sendNotification(currentJob->getBooking()->getCustomer(), title, message);
     }
 }

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

@@ -1,3 +1,11 @@
+/*
+File: ServiceManagementService.h
+Description: Header file declaring the ServiceManagementService class, which manages
+             services, combo packages, job cards, and service bookings. Inherits from
+             NotificationManagementService to handle notifications.
+Author: Trenser
+Date:19-May-2026
+*/
 #pragma once
 #include <string>
 #include "Map.h"
@@ -22,7 +30,6 @@ 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);
@@ -30,7 +37,7 @@ public:
     void completeJob(const std::string& jobID);
     void cancelCustomerServiceBookings(const std::string& customerID);
     void cancelTechnicianJobs(const std::string& technicianID);
-    void createComboPackage(const std::string& name, const util::Vector<std::string>& serviceIDs, double discountPercentage);
+    void createComboPackage(const std::string& packageName, const util::Vector<std::string>& serviceIDs, double discountPercentage);
     void removeComboPackage(const std::string& comboPackageID);
     void sendNotification(User* user, const std::string& title, const std::string& message) override;
     void attach(User* user) override;

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

@@ -1,31 +1,55 @@
+/*
+File: UserManagementService.cpp
+Description: Implementation file containing the method definitions of the
+			 UserManagementService class, including user retrieval and removal logic.
+Author: Trenser
+Date:19-May-2026
+*/
 #include "UserManagementService.h"
 #include "User.h"
 
-util::Map<std::string, User*> UserManagementService::getUsers(util::UserType type)
+/*
+Function: getUsers
+Description: Retrieves all users stored in the DataStore.
+Parameter: None
+Return type: util::Map<std::string, User*>
+*/
+util::Map<std::string, User*> UserManagementService::getUsers()
 {
-	util::Map<std::string, User*>& currentUsers = m_dataStore.getUsers();
+	return m_dataStore.getUsers();
-	util::Map<std::string, User*> filteredUsersMap;
-	for (int iterator = 0; iterator < currentUsers.getSize(); iterator++)
-	{
-		User* currentUser = currentUsers.getValueAt(iterator);
-		if (currentUser->getUserType() == type)
-		{
-			filteredUsersMap.insert(currentUser->getId(), currentUser);
-		}
-	}
-	return filteredUsersMap;
 }
 
+/*
+Function: getUser
+Description: Retrieves a specific user by ID from the DataStore.
+Parameter: const std::string& userID - ID of the user
+Return type: User*
+*/
 User* UserManagementService::getUser(const std::string& userID)
 {
-	util::Map<std::string, User*>& currentUsers = m_dataStore.getUsers();
+	int index = m_dataStore.getUsers().find(userID);
-	for (int iterator = 0; iterator < currentUsers.getSize(); iterator++)
+	if (index != -1)
 	{
-		User* currentUser = currentUsers.getValueAt(iterator);
+		return m_dataStore.getUsers().getValueAt(index);
-		if (currentUser->getId() == userID)
-		{
-			return currentUser;
-		}
 	}
 	return nullptr;
 }
+
+/*
+Function: removeUser
+Description: Marks a user as inactive in the DataStore instead of deleting them.
+Parameter: const std::string& userID - ID of the user to remove
+Return type: void
+*/
+void UserManagementService::removeUser(const std::string& userID)
+{
+	int index = m_dataStore.getUsers().find(userID);
+	if (index != -1)
+	{
+		User* user = m_dataStore.getUsers().getValueAt(index);
+		if (user != nullptr)
+		{
+			user->setState(util::State::INACTIVE);
+		}
+	}
+}

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

@@ -1,3 +1,10 @@
+/*
+File: UserManagementService.h
+Description: Header file declaring the UserManagementService class, which manages
+             user creation, updates, retrieval, removal, and notification handling.
+Author: Trenser
+Date:19-May-2026
+*/
 #pragma once
 #include <string>
 #include "Map.h"
@@ -13,7 +20,7 @@ private:
     DataStore& m_dataStore;
 public:
     UserManagementService() : m_dataStore(DataStore::getInstance()) {}
-    void createUser(const std::string& username, const std::string& password, const std::string& email, const std::string& phone, util::UserType type);
+    void createUser(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone, util::UserType type);
     void updateUserDetails(const std::string& userID, const std::string& email, const std::string& phone);
     util::Map<std::string, User*> getUsers();
     util::Map<std::string, User*> getUsers(util::UserType type);

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

@@ -26,7 +26,8 @@ namespace util
 	{
         PENDING,
 		STARTED,
-		COMPLETED
+		COMPLETED,
+        CANCELLED
 	};
 
     enum class State
@@ -122,12 +123,14 @@ namespace util
     {
         switch (status)
         {
+        case ServiceJobStatus::PENDING:
+            return "PENDING";
         case ServiceJobStatus::STARTED:
             return "STARTED";
         case ServiceJobStatus::COMPLETED:
             return "COMPLETED";
-        case ServiceJobStatus::PENDING:
+        case ServiceJobStatus::CANCELLED:
-            return "STARTED";
+            return "CANCELLED";
         }
         throw std::invalid_argument("Invalid ServiceJobStatus");
     }
@@ -142,6 +145,14 @@ namespace util
         {
             return ServiceJobStatus::COMPLETED;
         }
+        if (value == "PENDING")
+        {
+            return ServiceJobStatus::PENDING;
+        }
+        if (value == "CANCELLED")
+        {
+            return ServiceJobStatus::CANCELLED;
+        }
         throw std::invalid_argument("Invalid ServiceJobStatus string");
     }
 

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

@@ -0,0 +1,29 @@
+/*
+File: Utility.h
+Description: Header file declaring utility functions used across the system,
+             including cost calculation for services based on required inventory items.
+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;
+    auto& requiredInventoryItems = service->getRequiredInventoryItems();
+    int requiredInventoryItemsSize = requiredInventoryItems.getSize();
+    for (int index = 0; index < requiredInventoryItemsSize; index++)
+    {
+        cost += requiredInventoryItems.getValueAt(index)->getPrice();
+    }
+    return cost;
+}

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

@@ -1,27 +1,57 @@
+/*
+File: AdminMenu.cpp
+Description: Implementation file containing the method definitions of the
+			 AdminMenu class, including menu handling, inventory operations,
+			 user management, and combo package management functions.
+Author: Trenser
+Date:19-May-2026
+*/
+#include <iostream>
 #include <iomanip>
 #include "AdminMenu.h"
-#include "Service.h"
 #include "InputHelper.h"
 #include "OutputHelper.h"
-#include "ServiceBooking.h"
+#include "User.h"
-#include "Enums.h"
+#include "Validator.h"
 #include "Service.h"
-#include "InventoryItem.h"
+#include "Utility.h"
+#include "ComboPackage.h"
+#include "Enums.h"
 
+/*
+Function: showMenu
+Description: Displays the admin menu and handles user input until logout is selected.
+Parameter: None
+Return type: void
+*/
 void AdminMenu::showMenu()
 {
-	bool isMenuActive = true;
+    while (true)
-	while (isMenuActive)
     {
         try
         {
             int choice;
             util::clear();
-			std::cout << "" << std::endl;
+            std::cout << "Admin Menu"
+                << "\n1. View Stock Levels"
+                << "\n2. Add Inventory Item"
+                << "\n3. Remove Inventory Item"
+                << "\n4. Check Stock Availability"
+                << "\n5. Assign Job to Technician"
+                << "\n6. Add Technician"
+                << "\n7. Remove Customer/Technician"
+                << "\n8. Create Service"
+                << "\n9. Remove Service"
+                << "\n10. Create Combo Package"
+                << "\n11. Remove Combo Package"
+                << "\n12. View Notifications"
+                << "\n13. Change Password"
+                << "\n14. Logout"
+                << "\nEnter a choice: ";
             util::read(choice);
             if (!handleOperation(choice))
             {
-				isMenuActive = false;
+                break;
             }
         }
         catch (const std::exception& e)
@@ -32,18 +62,100 @@ void AdminMenu::showMenu()
     }
 }
 
+/*
+Function: handleOperation
+Description: Executes the corresponding admin operation based on the selected menu choice.
+Parameter: int choice - selected menu option
+Return type: bool - true if menu continues, false if logout
+*/
 bool AdminMenu::handleOperation(int choice)
 {
+    switch (choice)
+    {
+    case 1:
+        viewStockLevels();
+        break;
+    case 2:
+        addInventoryItem();
+        break;
+    case 3:
+        removeInventoryItem();
+        break;
+    case 4:
+        checkStockAvailability();
+        break;
+    case 5:
+        assignJob();
+        break;
+    case 6:
+        addTechnician();
+        break;
+    case 7:
+        removeUser();
+        break;
+    case 8:
+        createService();
+        break;
+    case 9:
+        removeService();
+        break;
+    case 10:
+        createComboPackages();
+        break;
+    case 11:
+        removeComboPackage();
+        break;
+    case 12:
+        viewNotifications();
+        break;
+    case 13:
+        changePassword();
+        break;
+    case 14:
+        logout();
         return false;
+    default:
+        std::cout << "Enter a valid choice!" << std::endl;
+        util::pressEnter();
+    }
+    return true;
 }
 
-
+/*
+Function: logout
+Description: Logs out the currently authenticated admin user.
+Parameter: None
+Return type: void
+*/
 void AdminMenu::logout()
 {
+	m_controller.logout();
 }
-
+/*
+Function: changePassword
+Description: Allows the admin to change their password after validation.
+Parameter: None
+Return type: void
+*/
 void AdminMenu::changePassword()
 {
+	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;
+		}
+		m_controller.changePassword(newPassword);
+		std::cout << "Password changed successfully\n";
+		util::pressEnter();
+		break;
+	}
 }
 
 void AdminMenu::viewStockLevels()
@@ -62,384 +174,341 @@ 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;
+void AdminMenu::removeService()
-	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)
+Function: addTechnician
-Description: Allows selection of a service to remove by index.
+Description: Adds a new technician after validating username, password, email, and phone number.
-Parameters:
+Parameter: None
-	- currentServices: util::Map<std::string, const Service*>, available services
+Return type: void
-Returns:
-	- std::string: ID of the selected service, or empty string if invalid
 */
-static std::string selectServicesToRemove(util::Map<std::string, const Service*> currentServices)
+void AdminMenu::addTechnician()
 {
-    util::Map<int, const Service*> currentServicesMap;
+	util::clear();
-    bool hasServices = false;
+	std::string username, name, password, email, phoneNumber;
-    int currentIndex = 1, choice;
+	std::cout << std::left << std::setw(25) << "Enter Technician Username: ";
-    std::cout << std::left
+	util::read(username);
-        << std::setw(6) << "Index"
+	std::cout << std::left << std::setw(25) << "Enter Technician Name: ";
-        << std::setw(12) << "Service ID"
+	util::read(name);
-        << std::setw(20) << "Name"
+	std::cout << std::setw(25) << "Enter Technician Password: ";
-        << std::setw(10) << "Labor Cost"
+	util::read(password);
-        << std::endl;
+	if(!util::isPasswordValid(password))
-    for (int iterator = 0; iterator < currentServices.getSize(); iterator++)
 	{
-        const Service* currentService = currentServices.getValueAt(iterator);
+		std::cout << "Error: Password is invalid!";
-        if (currentService->getState() == util::State::INACTIVE)
+		util::pressEnter();
+		return;
+	}
+	std::cout << std::setw(25) << "Enter Technician Email: ";
+	util::read(email);
+	if(!util::isEmailValid(email))
+	{
+		std::cout << "Error: Email is invalid!";
+		util::pressEnter();
+		return;
+	}
+	std::cout << std::setw(25) << "Enter Technician Phone: ";
+	util::read(phoneNumber);
+	if(!util::isPhoneNumberValid(phoneNumber))
+	{
+		std::cout << "Error: Phone Number is invalid!";
+		util::pressEnter();
+		return;
+	}
+	m_controller.createTechnician(username, name, password, email, phoneNumber);
+	std::cout << "\nTechnician Added Successfully.\n";
+	util::pressEnter();
+}
+
+/*
+Function: filterActiveUsers
+Description: Filters out inactive users and returns a map of active users.
+Parameter: const util::Map<std::string, const User*>& listOfUsers - all users
+Return type: util::Map<std::string, const User*>
+*/
+static util::Map<std::string, const User*>
+filterActiveUsers(const util::Map<std::string, const User*>& listOfUsers)
+{
+	util::Map<std::string, const User*> activeUsers;
+	int inventorySize = listOfUsers.getSize();
+	for (int index = 0; index < inventorySize; index++)
+	{
+		const User* user = listOfUsers.getValueAt(index);
+		if (user != nullptr && user->getState() != util::State::INACTIVE)
+		{
+			activeUsers.insert(user->getId(), user);
+		}
+	}
+	return activeUsers;
+}
+
+/*
+Function: displayAllActiveUsers
+Description: Displays all active users in a tabular format with index, ID, username, and type.
+Parameter: util::Map<std::string, const User*>& activeUsers - active users list
+		   int activeUserCount - number of active users
+Return type: void
+*/
+static void displayAllActiveUsers(util::Map<std::string, const User*>& activeUsers, int activeUserCount)
+{
+	std::cout << std::left << std::setw(10) << "Index"
+		<< std::setw(15) << "User ID"
+		<< std::setw(25) << "Username"
+		<< std::setw(25) << "User Type"
+		<< std::endl;
+	for (int iterator = 0; iterator < activeUserCount; iterator++)
+	{
+		const User* user = activeUsers.getValueAt(iterator);
+		if (user != nullptr)
+		{
+			std::cout << std::left << std::setw(10) << (iterator + 1)
+				<< std::setw(15) << user->getId()
+				<< std::setw(25) << user->getUserName()
+				<< std::setw(25) << util::getUserTypeString(user->getUserType())
+				<< std::endl;
+		}
+		else
+		{
+			std::cout << "No users found.\n";
+			util::pressEnter();
+			return;
+		}
+	}
+}
+
+/*
+Function: removeUser
+Description: Removes a selected active user (customer or technician) from the system.
+Parameter: None
+Return type: void
+*/
+void AdminMenu::removeUser()
+{
+	util::clear();
+	int indexChoice;
+	auto listOfUsers = m_controller.getUsers();
+	auto listOfActiveUsers = filterActiveUsers(listOfUsers);
+	int activeUserCount = listOfActiveUsers.getSize();
+	if (activeUserCount < 1)
+	{
+		std::cout << "No Active users." << std::endl;
+		util::pressEnter();
+		return;
+	}
+	displayAllActiveUsers(listOfActiveUsers, activeUserCount);
+	std::cout << "Enter the index of the user to delete : ";
+	util::read(indexChoice);
+	if (indexChoice < 1 || indexChoice > activeUserCount)
+	{
+		std::cout << "Error Invaild index.\n" << std::endl;
+		util::pressEnter();
+		return;
+	}
+	const User* userToRemove = listOfActiveUsers.getValueAt(indexChoice - 1);
+	if (userToRemove != nullptr)
+	{
+		std::string userIdToRemove = userToRemove->getId();
+		m_controller.removeUser(userIdToRemove);
+		std::cout << userToRemove->getUserName() << " removed Successfully.\n";
+	}
+	util::pressEnter();
+}
+
+/*
+Function: selectServiceFromServices
+Description: Displays active services and allows the admin 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(6) << currentIndex
+            << std::setw(10) << currentIndex
-            << std::setw(12) << currentService->getId()
+            << std::setw(15) << currentService->getId()
-            << std::setw(20) << currentService->getName()
+            << std::setw(25) << currentService->getName()
-            << std::setw(10) << currentService->getLaborCost()
+            << std::setw(15) << (currentService->getLaborCost() + partsCost)
             << std::endl;
-        hasServices = true;
+        currentIndex++;
-        currentServicesMap.insert(currentIndex++, currentService);
     }
-    if (!hasServices)
+    if (activeServicesMap.getSize() == 0)
     {
-        std::cout << "No services currently available." << std::endl;
+        std::cout << "No active services available." << std::endl;
-        return "";
+        return nullptr;
     }
-    std::cout << "Enter your choice: ";
+    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: createComboPackages
+Description: Creates a new combo package by selecting two active services and applying a discount.
+Parameter: None
+Return type: void
+*/
+void AdminMenu::createComboPackages()
+{
+	util::clear();
+	auto serviceList = m_controller.getServices();
+    const int numberOfServicesInPackage = 2;
+	util::Vector<std::string> selectedServiceID;
+    for (int iterator = 0; iterator < numberOfServicesInPackage; iterator++)
+    {
+        const Service* chosenService = selectServiceFromServices(serviceList);
+        if (chosenService == nullptr)
+        {
+            std::cout << "Failed to create combo package!";
+            util::pressEnter();
+            return;
+        }
+        selectedServiceID.push_back(chosenService->getId());
+        util::clear();
+    }
+    std::string packageName;
+    double discountPercentage;
+    std::cout << "Enter combo package name: ";
+    util::read(packageName);
+    std::cout << "Enter discount percentage: ";
+    util::read(discountPercentage);
+    if (discountPercentage < 0.0 || discountPercentage > 100.0)
+    {
+        std::cout << "Error: Discount percentage must be between 0 and 100." << std::endl;
+        util::pressEnter();
+        return;
+    }
+    m_controller.createComboPackage(packageName, selectedServiceID, discountPercentage);
+    std::cout << "Combo package '" << packageName << "' created successfully." << std::endl;
+    util::pressEnter();
+}
+
+/*
+Function: displayComboPackagesWithIndex
+Description: Displays combo packages with index, ID, name, and discount percentage.
+Parameter: util::Map<int, const ComboPackage*>& currentComboPackageIndexMap - combo packages map
+Return type: void
+*/
+static void displayComboPackagesWithIndex(util::Map<int, const ComboPackage*>& currentComboPackageIndexMap)
+{
+	for (int iterator = 0; iterator < currentComboPackageIndexMap.getSize(); iterator++)
+	{
+		const ComboPackage* currentComboPackage = currentComboPackageIndexMap.getValueAt(iterator);
+		if (currentComboPackage == nullptr)
+		{
+			throw std::runtime_error("Error accessing the combopackage.\n");
+		}
+		if (iterator == 0)
+		{
+			std::cout << std::left
+				<< std::setw(8) << "Index"
+				<< std::setw(10) << "ID"
+				<< std::setw(20) << "Package Name"
+				<< std::setw(15) << "Discount (%)"
+				<< "\n";
+		}
+		std::cout << std::left
+			<< std::setw(8) << currentComboPackageIndexMap.getKeyAt(iterator)
+			<< std::setw(10) << currentComboPackage->getId()
+			<< std::setw(20) << currentComboPackage->getPackageName()
+			<< std::setw(15) << currentComboPackage->getDiscountPercentage()
+			<< "\n";
+	}
+}
+
+/*
+Function: selectComboPackage
+Description: Allows the admin to select an active combo package by index.
+Parameter: util::Map<std::string, const ComboPackage*>& currentComboPackages - combo packages list
+Return type: std::string - ID of the selected combo package
+*/
+static std::string selectComboPackage(util::Map<std::string, const ComboPackage*>& currentComboPackages)
+{
+	util::Map<int, const ComboPackage*> currentComboPackageIndexMap;
+	if (currentComboPackages.getSize() == 0)
+	{
+		throw std::runtime_error("No combo packages are available.\n");
+	}
+	int currentIndex = 1, choice, selectedIndex;
+	for (int iterator = 0; iterator < currentComboPackages.getSize(); iterator++)
+	{
+		if (currentComboPackages.getValueAt(iterator)->getState() == util::State::INACTIVE)
+		{
+			continue;
+		}
+		currentComboPackageIndexMap.insert(currentIndex++, currentComboPackages.getValueAt(iterator));
+	}
+	if (currentComboPackageIndexMap.getSize() == 0)
+	{
+		throw std::runtime_error("No combo packages currently active.");
+	}
+	displayComboPackagesWithIndex(currentComboPackageIndexMap);
+	std::cout << "Enter your choice(Index): ";
 	util::read(choice);
-    if (currentServicesMap.find(choice) != -1)
+	selectedIndex = currentComboPackageIndexMap.find(choice);
+	if (selectedIndex != -1)
 	{
-        return currentServicesMap.getValueAt(currentServicesMap.find(choice))->getId();
+		std::string selectedComboPackageID = currentComboPackageIndexMap.getValueAt(selectedIndex)->getId();
+		return selectedComboPackageID;
 	}
 	else
 	{
-        std::cout << "Invalid choice." << std::endl;
+		std::cout << "Enter a valid choice.\n";
 		return "";
 	}
 }
 
 /*
-Function: removeService
+Function: removeComboPackage
-Description: Allows the admin to remove an existing service by selecting from available services.
+Description: Removes a selected combo package from the system.
-Parameters:
+Parameter: None
-	- None
+Return type: void
-Returns:
-	- void
 */
-void AdminMenu::removeService()
+void AdminMenu::removeComboPackage()
 {
 	util::clear();
-	std::string selectedServiceID;
+	util::Map<std::string, const ComboPackage*> currentComboPackages = m_controller.getComboPackages();
-	util::Map<std::string, const Service*> currentServices = m_controller.getServices();
+	std::string selectedComboPackageID = selectComboPackage(currentComboPackages);
-	selectedServiceID = selectServicesToRemove(currentServices);
+	if (selectedComboPackageID != "")
-	if (selectedServiceID != "")
 	{
-		m_controller.removeService(selectedServiceID);
+		m_controller.removeComboPackage(selectedComboPackageID);
-		std::cout << "Service removed sucessfully.";
+		std::cout << "Combo Package removed successfully.\n";
 	}
 	else
 	{
-		std::cout << "Failed  to remove service.";
+		std::cout << "Combo package removal failed.\n";
 	}
-}
+	util::pressEnter();
-
-void AdminMenu::addTechnician()
-{
-}
-
-void AdminMenu::removeUser()
-{
-}
-
-void AdminMenu::createComboPackages()
-{
-}
-
-void AdminMenu::removeComboPackage()
-{
 }
 
 void AdminMenu::viewNotifications()

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

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

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

@@ -1,10 +1,6 @@
-#include <iomanip>
 #include "CustomerMenu.h"
 #include "InputHelper.h"
 #include "OutputHelper.h"
-#include "User.h"
-#include "ServiceBooking.h"
-#include "Enums.h"
 
 void CustomerMenu::showMenu()
 {
@@ -55,55 +51,8 @@ void CustomerMenu::selectComboPackage()
 {
 }
 
-/*
-Function: viewServiceHistory
-Description: Displays the customer’s past service bookings in tabular format,
-             including booking ID, technician, vehicle details, discount percentage, and status.
-Parameters:
-    - None
-Returns:
-    - void
-*/
 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()

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

@@ -1,25 +1,40 @@
-#include <iomanip>
+/*
+File: TechnicianMenu.cpp
+Description: Implementation file containing the method definitions of the
+             TechnicianMenu class, including menu handling, job completion,
+             notification viewing, password management, and logout logic.
+Author: Trenser
+Date:19-May-2026
+*/
 #include "TechnicianMenu.h"
 #include "InputHelper.h"
 #include "OutputHelper.h"
-#include "JobCard.h"
+#include "Validator.h"
-#include "Enums.h"
-#include "Service.h"
 
+/*
+Function: showMenu
+Description: Displays the technician menu and handles user input until logout is selected.
+Parameter: None
+Return type: void
+*/
 void TechnicianMenu::showMenu()
 {
-	bool isMenuActive = true;
+    while (true)
-	while (isMenuActive)
     {
         try
         {
             int choice;
             util::clear();
-			std::cout << "" << std::endl;
+            std::cout << "Technician Menu"
+                << "\n1. Mark Job as Completed"
+                << "\n2. View Notifications"
+                << "\n3. Change Password"
+                << "\n4. Logout"
+                << "\nEnter a choice: ";
             util::read(choice);
             if (!handleOperation(choice))
             {
-				isMenuActive = false;
+                break;
             }
         }
         catch (const std::exception& e)
@@ -30,93 +45,78 @@ void TechnicianMenu::showMenu()
     }
 }
 
+/*
+Function: handleOperation
+Description: Executes the corresponding technician operation based on the selected menu choice.
+Parameter: int choice - selected menu option
+Return type: bool - true if menu continues, false if logout
+*/
 bool TechnicianMenu::handleOperation(int choice)
 {
+    switch (choice)
+    {
+    case 1:
+        completeJob();
+        break;
+    case 2:
+        viewNotifications();
+        break;
+    case 3:
+        changePassword();
+        break;
+    case 4:
+        logout();
         return false;
+    default:
+        std::cout << "Enter a valid choice!" << std::endl;
+        util::pressEnter();
+    }
+    return true;
 }
 
-/*
-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: completeJob
-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()
 {
 }
+
+/*
+Function: logout
+Description: Logs out the currently authenticated technician user.
+Parameter: None
+Return type: void
+*/
+void TechnicianMenu::logout()
+{
+	m_controller.logout();
+}
+
+/*
+Function: changePassword
+Description: Allows the technician to change their password after validation.
+Parameter: None
+Return type: void
+*/
+void TechnicianMenu::changePassword()
+{
+	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;
+		}
+		m_controller.changePassword(newPassword);
+		std::cout << "Password changed successfully\n";
+		util::pressEnter();
+		break;
+	}
+}

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

@@ -1,3 +1,11 @@
+/*
+File: TechnicianMenu.h
+Description: Header file declaring the TechnicianMenu class, which provides
+             technician operations such as job completion, notification viewing,
+             password management, and logout functionality.
+Author: Trenser
+Date:19-May-2026
+*/
 #pragma once
 #include "Controller.h"
 
@@ -10,4 +18,6 @@ public:
     void showMenu();
     void completeJob();
     void viewNotifications();
+    void logout();
+    void changePassword();
 };

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

@@ -1,7 +1,23 @@
+/*
+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 "User.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;
@@ -26,6 +42,12 @@ 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)
@@ -46,9 +68,47 @@ 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";
+	}
 }
 
 void UserInterface::registerCustomer()

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

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