476 lines
14 KiB
C++
476 lines
14 KiB
C++
/*
|
||
File: CustomerMenu.cpp
|
||
Description: Implementation file containing the method definitions of the
|
||
CustomerMenu class, including menu handling, service selection,
|
||
combo package booking, profile updates, and password management.
|
||
Author: Trenser
|
||
Date:19-May-2026
|
||
*/
|
||
|
||
#include <iomanip>
|
||
#include "ComboPackage.h"
|
||
#include "CustomerMenu.h"
|
||
#include "MenuHelper.h"
|
||
#include "Enums.h"
|
||
#include "InputHelper.h"
|
||
#include "OutputHelper.h"
|
||
#include "InventoryItem.h"
|
||
#include "Invoice.h"
|
||
#include "Map.h"
|
||
#include "Service.h"
|
||
#include "ServiceBooking.h"
|
||
#include "Timestamp.h"
|
||
#include "User.h"
|
||
#include "Validator.h"
|
||
#include "Vector.h"
|
||
|
||
/*
|
||
Function: showMenu
|
||
Description: Displays the customer menu and handles user input until logout is selected.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void CustomerMenu::showMenu()
|
||
{
|
||
|
||
startEventListener();
|
||
while (true)
|
||
{
|
||
try
|
||
{
|
||
if (!m_isMenuActive)
|
||
{
|
||
logout();
|
||
break;
|
||
}
|
||
int choice;
|
||
util::clear();
|
||
std::cout << "Customer Menu"
|
||
<< "\n1. Select a service"
|
||
<< "\n2. Select a combo package"
|
||
<< "\n3. Update Profile"
|
||
<< "\n4. Change Password"
|
||
<< "\n5. View Service History"
|
||
<< "\n6. Cancel Service Booking"
|
||
<< "\n7. Complete Payments"
|
||
<< "\n8. View Invoices"
|
||
<< "\n9. View Notifications"
|
||
<< "\n10. Configure Notifications"
|
||
<< "\n11. Logout"
|
||
<< "\nEnter a choice: ";
|
||
util::read(choice);
|
||
if (!handleOperation(choice))
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
catch (const std::exception& e)
|
||
{
|
||
std::cout << "Exception: " << e.what() << std::endl;
|
||
util::pressEnter();
|
||
}
|
||
}
|
||
stopEventListener();
|
||
}
|
||
|
||
/*
|
||
Function: handleOperation
|
||
Description: Executes the corresponding customer operation based on the selected menu choice.
|
||
Parameter: int choice - selected menu option
|
||
Return type: bool - true if menu continues, false if logout
|
||
*/
|
||
bool CustomerMenu::handleOperation(int choice)
|
||
{
|
||
if (!m_isMenuActive)
|
||
{
|
||
logout();
|
||
return false;
|
||
}
|
||
switch (choice)
|
||
{
|
||
case 1:
|
||
selectService();
|
||
break;
|
||
case 2:
|
||
selectComboPackage();
|
||
break;
|
||
case 3:
|
||
updateDetails();
|
||
break;
|
||
case 4:
|
||
changePassword();
|
||
break;
|
||
case 5:
|
||
viewServiceHistory();
|
||
break;
|
||
case 6:
|
||
cancelServiceBooking();
|
||
break;
|
||
case 7:
|
||
completePayments();
|
||
break;
|
||
case 8:
|
||
viewInvoices();
|
||
break;
|
||
case 9:
|
||
viewNotifications();
|
||
break;
|
||
case 10:
|
||
configureNotifications();
|
||
break;
|
||
case 11:
|
||
logout();
|
||
return false;
|
||
default:
|
||
std::cout << "Enter a valid choice!" << std::endl;
|
||
util::pressEnter();
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/*
|
||
Function: handleNotificationEvent
|
||
Description: Retrieves and displays the latest notification for the
|
||
currently logged in admin.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void CustomerMenu::handleNotificationEvent()
|
||
{
|
||
auto notifications = m_controller.getNotifications();
|
||
const User* authenticatedUser = m_controller.getAuthenticatedUser();
|
||
std::string name;
|
||
if (authenticatedUser)
|
||
{
|
||
name = authenticatedUser->getName();
|
||
}
|
||
displayNewNotification(notifications, name);
|
||
}
|
||
|
||
/*
|
||
Function: logout
|
||
Description: Logs out the currently authenticated customer user.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void CustomerMenu::logout()
|
||
{
|
||
m_controller.logout();
|
||
}
|
||
|
||
/*
|
||
Function: changePassword
|
||
Description: Allows the customer to change their password after validation.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void CustomerMenu::changePassword()
|
||
{
|
||
changePasswordHelper(m_controller);
|
||
}
|
||
|
||
/*
|
||
Function: updateDetails
|
||
Description: Allows the customer to update their email and phone number after validation.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void CustomerMenu::updateDetails()
|
||
{
|
||
std::string email, phone;
|
||
util::clear();
|
||
std::cout << "Update Details\n";
|
||
std::cout << "Enter new email: ";
|
||
util::read(email);
|
||
if (!util::isEmailValid(email))
|
||
{
|
||
std::cout << "Error: Email is invalid!\n";
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
std::cout << "Enter new phone: ";
|
||
util::read(phone);
|
||
if (!util::isPhoneNumberValid(phone))
|
||
{
|
||
std::cout << "Error: Phone number is invalid!\n";
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
m_controller.updateUserDetails(email, phone);
|
||
std::cout << "Profile details updated successfully\n";
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: selectService
|
||
Description: Allows the customer to select a service, provide vehicle details,
|
||
and book the service through the controller.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void CustomerMenu::selectService()
|
||
{
|
||
std::string vehicleNumber, vehicleBrand, vehicleModel;
|
||
util::clear();
|
||
std::cout << "Select a Service\n";
|
||
auto services = m_controller.getServices();
|
||
if (services.isEmpty())
|
||
{
|
||
std::cout << "No services available!";
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
util::Vector<std::string> selectedServices;
|
||
const Service* selectedService = selectServiceFromServices(services);
|
||
if (selectedService == nullptr)
|
||
{
|
||
std::cout << "Failed to book service!";
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
selectedServices.push_back(selectedService->getId());
|
||
util::clear();
|
||
std::cout << "Enter Vehicle Details\n";
|
||
std::cout << "Enter vehicle number: ";
|
||
util::read(vehicleNumber);
|
||
std::cout << "Enter vehicle brand: ";
|
||
util::read(vehicleBrand);
|
||
std::cout << "Enter vehicle model: ";
|
||
util::read(vehicleModel);
|
||
m_controller.purchaseService(selectedServices, vehicleNumber, vehicleBrand, vehicleModel);
|
||
std::cout << "Service has been booked successfully";
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: selectComboPackage
|
||
Description: Allows the customer to select a combo package, provide vehicle details,
|
||
and book the package through the controller.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void CustomerMenu::selectComboPackage()
|
||
{
|
||
std::string vehicleNumber, vehicleBrand, vehicleModel;
|
||
util::clear();
|
||
std::cout << "Select a Combo Package\n";
|
||
auto comboPackages = m_controller.getComboPackages();
|
||
util::Map<std::string, const ComboPackage*> activeComboPackages = filterComboPackages(comboPackages);
|
||
if (activeComboPackages.isEmpty())
|
||
{
|
||
std::cout << "No combo packages available!\n\n";
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
const ComboPackage* selectedComboPackage = selectComboPackageFromPackages(activeComboPackages);
|
||
if (selectedComboPackage == nullptr)
|
||
{
|
||
std::cout << "Failed to book combo package!\n\n";
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
std::cout << "Combo Package selected\n";
|
||
util::pressEnter();
|
||
util::clear();
|
||
std::cout << "Enter the vehicle details\n";
|
||
std::cout << "Enter vehicle number: ";
|
||
util::read(vehicleNumber);
|
||
std::cout << "Enter vehicle brand: ";
|
||
util::read(vehicleBrand);
|
||
std::cout << "Enter vehicle model: ";
|
||
util::read(vehicleModel);
|
||
m_controller.purchaseComboPackage(selectedComboPackage->getId(), vehicleNumber, vehicleBrand, vehicleModel);
|
||
std::cout << "Combo Package has been booked successfully\n\n";
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
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);
|
||
std::cout << "View Service History" << std::endl;
|
||
if (serviceBookingsByCurrentUser.getSize() != 0)
|
||
{
|
||
std::cout << std::left
|
||
<< std::setw(15) << "Booking ID"
|
||
<< std::setw(20) << "Technician"
|
||
<< std::setw(20) << "Vehicle Brand"
|
||
<< std::setw(20) << "Vehicle Number"
|
||
<< std::setw(20) << "Vehicle Model"
|
||
<< std::setw(20) << "Discount %"
|
||
<< std::setw(20) << "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(15) << currentBooking->getId()
|
||
<< std::setw(20) << technicianName
|
||
<< std::setw(20) << currentBooking->getVehicleBrand()
|
||
<< std::setw(20) << currentBooking->getVehicleNumber()
|
||
<< std::setw(20) << currentBooking->getVehicleModel()
|
||
<< std::setw(20) << currentBooking->getDiscountPercentage()
|
||
<< std::setw(20) << util::getServiceJobStatusString(currentBooking->getStatus())
|
||
<< std::endl;
|
||
hasServiceHistory = true;
|
||
}
|
||
}
|
||
if (!hasServiceHistory)
|
||
{
|
||
std::cout << "No history available." << std::endl;
|
||
}
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: cancelServiceBooking
|
||
Description: Allows the customer to cancel a pending service booking.
|
||
Displays the list of active bookings, lets the user select one,
|
||
and removes it from the system. If no bookings are available,
|
||
an appropriate message is shown.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void CustomerMenu::cancelServiceBooking()
|
||
{
|
||
util::clear();
|
||
std::cout << "Cancel Service Booking\n";
|
||
const User* currentUser = m_controller.getAuthenticatedUser();
|
||
std::string currentUserID = currentUser->getId();
|
||
util::Map<std::string, const ServiceBooking*> serviceBookingsByCurrentUser = m_controller.getServiceBookingsByUser(currentUserID);
|
||
util::Map<int, const ServiceBooking*> serviceBookingsMap;
|
||
auto currentPendingServiceBookings = filterActiveServiceBookings(serviceBookingsByCurrentUser);
|
||
int bookingsSize = currentPendingServiceBookings.getSize();
|
||
if (listServiceBookings(currentPendingServiceBookings, bookingsSize, serviceBookingsMap))
|
||
{
|
||
const ServiceBooking* selectedService = selectPendingServiceBookings(serviceBookingsMap);
|
||
if (selectedService)
|
||
{
|
||
m_controller.removeServiceBooking(selectedService->getId());
|
||
std::cout << "Cancelled Service booking of id " + selectedService->getId() << std::endl << std::endl;
|
||
}
|
||
else
|
||
{
|
||
std::cout << "Invalid service booking index.\n\n";
|
||
return;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
std::cout << "No pending service bookings available.\n\n";
|
||
}
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: completePayments
|
||
Description: Allows the customer to complete pending payments for invoices.
|
||
Validates invoice selection and payment mode before completing payment.
|
||
Parameters:
|
||
- None
|
||
Returns:
|
||
- void
|
||
*/
|
||
void CustomerMenu::completePayments()
|
||
{
|
||
util::clear();
|
||
std::cout << "Complete Payments\n";
|
||
util::Map<std::string, const Invoice*> currentInvoices = m_controller.getInvoicesByUser();
|
||
if (currentInvoices.isEmpty())
|
||
{
|
||
std::cout << "No pending invoices available for payment.\n";
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
bool hasPending = false;
|
||
for (int index = 0; index < currentInvoices.getSize(); ++index)
|
||
{
|
||
const Invoice* invoice = currentInvoices.getValueAt(index);
|
||
if (invoice && invoice->getStatus() == util::PaymentStatus::PENDING)
|
||
{
|
||
hasPending = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!hasPending)
|
||
{
|
||
std::cout << "No pending invoices available for payment.\n";
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
std::string selectedID = selectInvoiceFromUserForPayment(currentInvoices, util::PaymentStatus::PENDING);
|
||
if (selectedID == "")
|
||
{
|
||
std::cout << "Payment failed.\n";
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
util::PaymentMode paymentMode = selectPaymentMode();
|
||
m_controller.completePayment(selectedID, paymentMode);
|
||
std::cout << "Payment completed successfully.\n";
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: viewInvoices
|
||
Description: Displays invoices associated with the customer by calling displayInvoices.
|
||
Parameters:
|
||
- None
|
||
Returns:
|
||
- void
|
||
*/
|
||
void CustomerMenu::viewInvoices()
|
||
{
|
||
util::clear();
|
||
std::cout << "View Invoices\n";
|
||
util::Map<std::string, const Invoice*> currentUserInvoices = m_controller.getInvoicesByUser();
|
||
displayInvoices(currentUserInvoices);
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: viewNotifications
|
||
Description: Displays notifications for the customer and allows deletion of notifications.
|
||
Parameters:
|
||
- None
|
||
Returns:
|
||
- void
|
||
*/
|
||
void CustomerMenu::viewNotifications()
|
||
{
|
||
viewAndDeleteNotification(m_controller);
|
||
}
|
||
|
||
|
||
/*
|
||
Function: configureNotifications
|
||
Description: Allows the customer to configure notification preferences for payment and service management.
|
||
Parameters:
|
||
- None
|
||
Returns:
|
||
- void
|
||
*/
|
||
void CustomerMenu::configureNotifications()
|
||
{
|
||
bool paymentServiceNotifications = getNotificationPreference("Payment Management Service");
|
||
bool serviceManagementNotifications = getNotificationPreference("Service Management Service");
|
||
m_controller.configureNotifications(paymentServiceNotifications, serviceManagementNotifications);
|
||
util::clear();
|
||
std::cout << "Notification preferences updated successfully.\n";
|
||
util::pressEnter();
|
||
} |