Implement Remove Customer or Technician Functionality

<UserStory> ADM002: Remove Technician or Customer </UserStory>

<Changes>
    1. Integrated UserManagementService and ServiceManagementService into Controller for user removal operations.
    2. Added Controller::removeUser to validate user existence, cancel related service bookings and technician jobs, and mark user inactive.
    3. Updated JobCard and ServiceBooking models to use util::ServiceJobStatus consistently and store technician references as User* instead of strings.
    4. Extended util::ServiceJobStatus enum with PENDING and CANCELLED states, including string conversion support.
    5. Implemented ServiceManagementService methods to cancel customer service bookings and technician jobs, with inventory restocking and notifications.
    6. Enhanced AdminMenu::removeUser to list active users, validate index input, confirm deletion, and invoke Controller::removeUser.
    7. Added helper functions in AdminMenu to filter active users and display them with formatted output including user type.
</Changes>

<Test>

  Precondition:
  1. Admin is logged into the system.
  2. Technician accounts exist in the system.
  3. Technician has active job assignments.

  Steps:
  1. Navigate to Admin Menu and select "Remove User".
  2. System displays list of active users with IDs, usernames, and user types.
    - Verify that inactive users are excluded from the list.
  3. Admin selects technician ID for removal.
    - Verify that system confirms deletion before proceeding.
  4. Technician is removed from job assignment list.
    - Verify that associated jobs are cancelled, inventory is restocked, and notifications are sent.
</Test>

<Review>
Sreeja Reghukumar
</Review>

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

@@ -1 +1,100 @@
 #include "ServiceManagementService.h"
+#include "DataStore.h"
+#include "ServiceBooking.h"
+#include "JobCard.h"
+#include "Service.h"
+#include "InventoryItem.h"
+
+void ServiceManagementService::cancelCustomerServiceBookings(const std::string& userID)
+{
+    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);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+void ServiceManagementService::cancelTechnicianJobs(const std::string& technicianID)
+{
+    const int INCREMENT_VALUE = 1;
+    auto& jobs = m_dataStore.getJobCards();
+    for (int jobIterator = 0; jobIterator < jobs.getSize(); jobIterator++)
+    {
+        JobCard* job = jobs.getValueAt(jobIterator);
+        if (job != nullptr && job->getTechnicianId() == technicianID)
+        {
+            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);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -1 +1,30 @@
 #include "UserManagementService.h"
+#include "User.h"
+
+util::Map<std::string, User*> UserManagementService::getUsers()
+{
+	return m_dataStore.getUsers();
+}
+
+User* UserManagementService::getUser(const std::string& userID)
+{
+	int index = m_dataStore.getUsers().find(userID);
+	if (index != -1)
+	{
+		return m_dataStore.getUsers().getValueAt(index);
+	}
+	return nullptr;
+}
+
+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);
+		}
+	}
+}